> ## Documentation Index
> Fetch the complete documentation index at: https://resq-dependabot-github-actions-github-actions-478e18be3d.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Tools

<a id="resq_mcp.dtsop.tools" />

# resq\_mcp.dtsop.tools

MCP tool wrappers for DTSOP domain.

<a id="resq_mcp.dtsop.tools.logging" />

## logging

<a id="resq_mcp.dtsop.tools.UTC" />

## UTC

<a id="resq_mcp.dtsop.tools.datetime" />

## datetime

<a id="resq_mcp.dtsop.tools.Context" />

## Context

<a id="resq_mcp.dtsop.tools.FastMCPError" />

## FastMCPError

<a id="resq_mcp.dtsop.tools.OptimizationStrategy" />

## OptimizationStrategy

<a id="resq_mcp.dtsop.tools.SimulationRequest" />

## SimulationRequest

<a id="resq_mcp.dtsop.tools.get_optimization_strategy" />

## get\_optimization\_strategy

<a id="resq_mcp.dtsop.tools.trigger_sim" />

## trigger\_sim

<a id="resq_mcp.dtsop.tools.MAX_SIMULATIONS" />

## MAX\_SIMULATIONS

<a id="resq_mcp.dtsop.tools.incidents" />

## incidents

<a id="resq_mcp.dtsop.tools.mcp" />

## mcp

<a id="resq_mcp.dtsop.tools.simulations" />

## simulations

<a id="resq_mcp.dtsop.tools.logger" />

#### logger

<a id="resq_mcp.dtsop.tools.run_simulation" />

#### run\_simulation

```python theme={null}
@mcp.tool()
async def run_simulation(request: SimulationRequest,
                         ctx: Context | None = None) -> str
```

Trigger a Digital Twin physics simulation for disaster scenario modeling.

Queues a high-fidelity simulation job and returns immediately with a
job ID. Clients should subscribe to the simulation resource URI for
real-time progress updates and result notification.

Workflow:

1. Validate simulation request parameters
2. Generate unique simulation ID
3. Queue job to DTSOP backend (Unity/Unreal Engine)
4. Store job metadata in simulation registry
5. Return simulation ID and subscription URI
6. Background processor updates status -> processing -> completed
7. Client fetches results from NeoFS when completed

**Arguments**:

* `request` - SimulationRequest with:
  * scenario\_id: Unique scenario identifier
  * sector\_id: Geographic sector to simulate
  * disaster\_type: Physics model (flood/wildfire/earthquake)
  * parameters: Scenario params (wind\_speed, water\_level, etc.)
  * priority: "standard" or "urgent"
* `ctx` - Optional FastMCP context for logging.

**Returns**:

* `str` - Message with simulation ID and subscription instructions:
  "Simulation queued with ID: SIM-XXXXXXXX.
  Subscribe to resq://simulations/SIM-XXXXXXXX for updates."

**Example**:

> > > from resq\_mcp.dtsop.models import SimulationRequest
> > > request = SimulationRequest(
> > > ...     scenario\_id="flood-001",
> > > ...     sector\_id="Sector-1",
> > > ...     disaster\_type="flood",
> > > ...     parameters=\{"water\_level": 2.5},
> > > ...     priority="urgent"
> > > ... )
> > > result = await run\_simulation(request)
> > > print(result)  # "Simulation queued with ID: SIM-ABCD1234..."

Integration:
Production would:

* Validate request against simulation templates
* Check cluster capacity and queue position
* Store job in Redis with priority
* Submit to Unity/Unreal Engine processing cluster
* Return estimated completion time

<a id="resq_mcp.dtsop.tools.get_deployment_strategy" />

#### get\_deployment\_strategy

```python theme={null}
@mcp.tool()
async def get_deployment_strategy(incident_id: str) -> OptimizationStrategy
```

Generate an RL-optimized drone deployment and evacuation strategy.

Uses reinforcement learning models trained on thousands of simulated
disasters to recommend optimal resource allocation, routing, and
risk parameters for a specific incident or pre-alert.

**Arguments**:

* `incident_id` - Incident identifier (INC-XXX) or pre-alert ID (PRE-XXX)
  to generate strategy for.

**Returns**:

* `OptimizationStrategy` - Complete strategy recommendation with:
  * strategy\_id: Unique identifier
  * related\_alert\_id: Original incident/alert ID
  * recommended\_deployment: Drone type counts
  * evacuation\_routes: Prioritized route list
  * estimated\_success\_rate: Predicted success (0.0-1.0)
  * simulation\_proof\_url: NeoFS evidence link

**Example**:

> > > strategy = await get\_deployment\_strategy("PRE-ABC123")
> > > print(strategy.strategy\_id)
> > > print(strategy.recommended\_deployment)  # \{"surveillance": 2, ...}
> > > print(f"Success rate: \{strategy.estimated\_success\_rate:.0%}")

Use Cases:

* Pre-positioning drones before predicted disasters (PDIE alerts)
* Active response optimization for confirmed incidents
* Multi-objective optimization (speed, safety, resource efficiency)
* Scenario comparison and sensitivity analysis

Integration:
Strategy linked to blockchain for immutable audit trail.
After approval, use update\_mission\_params to push to drones.