JoeYing
Add ReScopeBench cases and task preview
f726fd6
Raw History Blame Contribute Delete
64.9 kB
"""Shared emergency response tool implementation."""
from __future__ import annotations
from datetime import datetime, timezone
from typing import Any, Dict, Optional
from mcp_servers.state.state_manager import StateManager
from mcp_servers.state.state_views import ACTIVE_ASSIGNMENT_STATUSES, OPEN_TASK_STATUSES
from mcp_servers.utils import build_humanized_id, error_response, is_non_empty_string, now_iso, parse_iso_datetime, safe_copy, success_response
AGENCY_TYPES={"emergency_management","fire","police","public_works","health","transportation","utilities","volunteer","county","state"}
COORDINATION_STATUSES={"active","standby","mutual_aid","demobilized"}
INCIDENT_STATUSES={"reported","assessing","active","contained","recovery","closed"}
SEVERITIES={"watch","minor","moderate","major","catastrophic"}; SEVERITY_PRIORITY={"watch":1,"minor":2,"moderate":3,"major":4,"catastrophic":5}
INCIDENT_TYPES={"flood","wildfire","winter_storm","hazardous_material","severe_weather","infrastructure_failure","evacuation_support"}
RESOURCE_TYPES={"engine","ambulance","high_water_vehicle","rescue_boat","shelter_team","damage_assessment_team","debris_crew","generator","communications_trailer","traffic_control_team"}
RESOURCE_STATUSES={"available","staged","assigned","enroute","maintenance","out_of_service"}
ASSIGNMENT_PRIORITIES={"routine","urgent","life_safety"}
SHELTER_STATUSES={"standby","open","full","restricted","closing","closed"}; SUPPLIES_STATUSES={"adequate","needs_restock","critical"}; GENERATOR_STATUSES={"available","limited","offline"}
ROUTE_STATUSES={"open","restricted","closed","staged"}; HAZARD_LEVELS={"clear","monitored","caution","blocked"}
DAMAGE_LEVELS={"none","minor","moderate","major","destroyed"}; SAFETY_STATUSES={"safe","restricted","unsafe"}
TASK_TYPES={"debris_clearance","utility_restoration","road_repair","shelter_demobilization","welfare_check","permit_review","public_notice"}; TASK_PRIORITIES={"low","normal","high","critical"}
COMM_CHANNELS={"radio","operations_call","email","public_alert","mutual_aid_portal"}; MESSAGE_PRIORITIES={"routine","urgent","life_safety"}
AID_URGENCIES={"routine","urgent","immediate"}; AID_DECISIONS={"approved","denied","fulfilled"}
TOOL_DESCRIPTIONS={
"list_agencies":"Retrieve emergency-management agencies with optional filters.","get_operational_dashboard":"Return a deterministic command dashboard.","get_incident_detail":"Retrieve one incident with linked operational context.","list_incidents":"List incidents with operational filters.","list_resource_units":"List dispatchable personnel, vehicles, and equipment.","get_resource_unit_status":"Retrieve one resource unit with assignment context.","list_shelters":"List shelters with capacity and status filters.","get_shelter_status":"Retrieve one shelter with occupancy totals.","list_evacuation_routes":"List evacuation routes with status and hazard filters.","search_communications":"Search inter-agency communication logs.",
"create_incident_report":"Create a new incident report.","update_incident_status":"Move an incident through the standard lifecycle.","assign_resource_to_incident":"Create a resource assignment and dispatch a resource.","release_resource_assignment":"Release an active resource assignment.","update_resource_status":"Update a resource unit status.","open_shelter_intake":"Open or reactivate shelter intake.","register_shelter_occupancy":"Register an intake batch at an open shelter.","update_shelter_capacity":"Update shelter capacity and operating state.","close_evacuation_route":"Close or restrict an evacuation route.","record_damage_assessment":"Record a field damage assessment.","assign_recovery_task":"Create a recovery task for an incident.","log_interagency_message":"Append an inter-agency communication log entry.",
"escalate_incident_severity":"Escalate or de-escalate incident severity.","open_evacuation_route":"Reopen a restricted or closed evacuation route.","reroute_evacuee_flow":"Shift evacuee flow between routes.","request_mutual_aid":"Submit or draft a mutual-aid request.","approve_mutual_aid_request":"Approve, deny, or fulfill a mutual-aid request.","schedule_resource_redeployment":"Release and redeploy a resource atomically.","finalize_recovery_task":"Complete or cancel a recovery task.","close_incident_with_recovery_check":"Close an incident after operational blockers are resolved."}
TOOL_SCHEMAS={name:{"type":"object","properties":{},"required":[]} for name in TOOL_DESCRIPTIONS}
def _sm(state_manager: Optional[StateManager]) -> StateManager:
if state_manager is not None: return state_manager
from mcp_servers.server import get_state_manager
return get_state_manager()
def _get(sm,eid_type,eid): return sm.get_entity(eid_type,eid) if isinstance(eid,str) and eid else None
def _err_if_missing(kwargs, fields, code='MISSING_REQUIRED_FIELD'):
for f in fields:
v=kwargs.get(f)
if v is None or (isinstance(v,str) and not v.strip()): return error_response(code, f"{f} is required")
return None
def _enum(value, allowed, code, label): return error_response(code, f"{label} is not allowed") if value is not None and value not in allowed else None
def _page(records, limit, offset): return records[offset:offset+limit]
def _validate_page(limit, offset): return error_response('OUT_OF_RANGE','limit or offset is outside the allowed range') if not isinstance(limit,int) or limit<1 or limit>100 or not isinstance(offset,int) or offset<0 else None
def _sort(records, field, order): return sorted(records, key=lambda r: r.get(field) if r.get(field) is not None else '', reverse=order=='desc')
def _time(value, code):
parsed=parse_iso_datetime(value)
return (parsed, None) if parsed else (None, error_response(code, 'timestamp is malformed'))
def _make_id(sm, entity, record):
id_field={'incident':'incident_id','resource_assignment':'assignment_id','shelter_occupancy':'occupancy_id','damage_assessment':'assessment_id','recovery_task':'task_id','mutual_aid_request':'aid_request_id','communication_log':'message_id'}[entity]
return build_humanized_id(entity, record, existing_ids=[x.get(id_field) for x in sm.list_entities(entity)])
def _summary(record, keys): return {k: record.get(k) for k in keys} if record else None
def list_agencies(state_manager=None, **kwargs):
sm=_sm(state_manager); agency_type=kwargs.get('agency_type'); status=kwargs.get('coordination_status'); limit=kwargs.get('limit',25); offset=kwargs.get('offset',0); sort_by=kwargs.get('sort_by','name'); sort_order=kwargs.get('sort_order','asc')
for err in [_enum(agency_type,AGENCY_TYPES,'INVALID_AGENCY_TYPE','agency_type'),_enum(status,COORDINATION_STATUSES,'INVALID_COORDINATION_STATUS','coordination_status'),_validate_page(limit,offset)]:
if err: return err
if sort_by not in {'name','agency_type','updated_at'} or sort_order not in {'asc','desc'}: return error_response('INVALID_SORT','sort_by or sort_order is invalid')
rows=sm.list_entities('agency')
if agency_type: rows=[r for r in rows if r.get('agency_type')==agency_type]
if status: rows=[r for r in rows if r.get('coordination_status')==status]
if kwargs.get('jurisdiction_query'): rows=[r for r in rows if kwargs['jurisdiction_query'].lower() in r.get('jurisdiction','').lower()]
rows=_sort(rows,sort_by,sort_order); keys=['agency_id','name','agency_type','jurisdiction','dispatch_channel','contact_email','coordination_status']
return success_response({'total_count':len(rows),'agencies':[_summary(r,keys) for r in _page(rows,limit,offset)]})
def get_operational_dashboard(state_manager=None, **kwargs):
sm=_sm(state_manager); st=kwargs.get('incident_status'); ag=kwargs.get('lead_agency_id')
if _enum(st,INCIDENT_STATUSES,'INVALID_INCIDENT_STATUS','incident_status'): return _enum(st,INCIDENT_STATUSES,'INVALID_INCIDENT_STATUS','incident_status')
if ag and not _get(sm,'agency',ag): return error_response('AGENCY_NOT_FOUND','no agency matches lead_agency_id')
rows=sm.list_entities('incident')
if st: rows=[r for r in rows if r.get('status')==st]
if ag: rows=[r for r in rows if r.get('lead_agency_id')==ag]
data={'core_state':sm.get_core_state(),'filtered_incident_count':len(rows),'critical_incidents':[_summary(r,['incident_id','title','status','severity','affected_area']) for r in rows if r.get('severity') in {'major','catastrophic'}][:10],'resource_pressure':sm.get_core_state()['resource_dispatch'],'shelter_pressure':sm.get_core_state()['shelter_operations'],'route_pressure':sm.get_core_state()['evacuation_network']}
if kwargs.get('include_recent_messages'): data['recent_messages']=[_summary(r,['message_id','incident_id','subject','priority','sent_at']) for r in sorted(sm.list_entities('communication_log'),key=lambda x:x.get('sent_at') or '', reverse=True)[:5]]
return success_response(data)
def get_incident_detail(state_manager=None, **kwargs):
sm=_sm(state_manager); iid=kwargs.get('incident_id')
if not is_non_empty_string(iid): return error_response('MISSING_INCIDENT_ID','incident_id is missing')
inc=_get(sm,'incident',iid)
if not inc: return error_response('INCIDENT_NOT_FOUND','no incident matches incident_id')
data={'incident':inc,'relationship_counts':{}}
maps={'assignments':('resource_assignment','incident_id'),'shelters':('shelter','active_incident_id'),'routes':('evacuation_route','active_incident_id'),'assessments':('damage_assessment','incident_id'),'recovery_tasks':('recovery_task','incident_id'),'aid_requests':('mutual_aid_request','incident_id'),'communications':('communication_log','incident_id')}
for name,(ent,field) in maps.items():
vals=[r for r in sm.list_entities(ent) if r.get(field)==iid]; data['relationship_counts'][name]=len(vals)
if kwargs.get('include_history',True): data[name]=vals[:20]
return success_response(data)
def list_incidents(state_manager=None, **kwargs):
sm=_sm(state_manager); limit=kwargs.get('limit',25); offset=kwargs.get('offset',0); sort_by=kwargs.get('sort_by','reported_at'); sort_order=kwargs.get('sort_order','desc')
for val,allowed,code,label in [(kwargs.get('status'),INCIDENT_STATUSES,'INVALID_INCIDENT_STATUS','status'),(kwargs.get('severity'),SEVERITIES,'INVALID_SEVERITY','severity'),(kwargs.get('incident_type'),INCIDENT_TYPES,'INVALID_INCIDENT_TYPE','incident_type')]:
err=_enum(val,allowed,code,label)
if err: return err
if _validate_page(limit,offset): return _validate_page(limit,offset)
if kwargs.get('lead_agency_id') and not _get(sm,'agency',kwargs['lead_agency_id']): return error_response('AGENCY_NOT_FOUND','no agency matches lead_agency_id')
if sort_by not in {'reported_at','updated_at','priority','severity'} or sort_order not in {'asc','desc'}: return error_response('INVALID_SORT','sort_by or sort_order is invalid')
rows=sm.list_entities('incident')
for k in ['status','severity','incident_type','lead_agency_id']:
if kwargs.get(k): rows=[r for r in rows if r.get(k)==kwargs[k]]
if kwargs.get('area_query'): rows=[r for r in rows if kwargs['area_query'].lower() in r.get('affected_area','').lower()]
rows=_sort(rows,sort_by,sort_order); keys=['incident_id','title','incident_type','severity','status','priority','lead_agency_id','affected_area','reported_at','updated_at','active_resource_count','sheltering_required','evacuation_required']
return success_response({'total_count':len(rows),'incidents':[_summary(r,keys) for r in _page(rows,limit,offset)]})
def list_resource_units(state_manager=None, **kwargs):
sm=_sm(state_manager); limit=kwargs.get('limit',25); offset=kwargs.get('offset',0); sort_by=kwargs.get('sort_by','resource_type'); sort_order=kwargs.get('sort_order','asc')
for val,allowed,code,label in [(kwargs.get('resource_type'),RESOURCE_TYPES,'INVALID_RESOURCE_TYPE','resource_type'),(kwargs.get('status'),RESOURCE_STATUSES,'INVALID_RESOURCE_STATUS','status')]:
err=_enum(val,allowed,code,label)
if err: return err
if _validate_page(limit,offset): return _validate_page(limit,offset)
if kwargs.get('owning_agency_id') and not _get(sm,'agency',kwargs['owning_agency_id']): return error_response('AGENCY_NOT_FOUND','no agency matches owning_agency_id')
if kwargs.get('current_incident_id') and not _get(sm,'incident',kwargs['current_incident_id']): return error_response('INCIDENT_NOT_FOUND','no incident matches current_incident_id')
if sort_by not in {'resource_type','status','fuel_or_supply_percent','updated_at'} or sort_order not in {'asc','desc'}: return error_response('INVALID_SORT','sort invalid')
rows=sm.list_entities('resource_unit')
for k in ['resource_type','status','owning_agency_id','current_incident_id']:
if kwargs.get(k): rows=[r for r in rows if r.get(k)==kwargs[k]]
if kwargs.get('capability_tag'): rows=[r for r in rows if any(kwargs['capability_tag'].lower() in str(t).lower() for t in r.get('capability_tags',[]))]
rows=_sort(rows,sort_by,sort_order); keys=['resource_id','owning_agency_id','resource_type','capability_tags','status','current_incident_id','staging_location','crew_size','fuel_or_supply_percent','last_status_at']
out=[]
for r in _page(rows,limit,offset):
item=_summary(r,keys); item['low_supply']=int(r.get('fuel_or_supply_percent') or 0)<30; out.append(item)
return success_response({'total_count':len(rows),'resources':out})
def get_resource_unit_status(state_manager=None, **kwargs):
sm=_sm(state_manager); rid=kwargs.get('resource_id')
if not is_non_empty_string(rid): return error_response('MISSING_RESOURCE_ID','resource_id is missing')
res=_get(sm,'resource_unit',rid)
if not res: return error_response('RESOURCE_NOT_FOUND','no resource matches resource_id')
data={'resource':res,'owning_agency':_summary(_get(sm,'agency',res.get('owning_agency_id')),['agency_id','name','agency_type','coordination_status']),'current_incident':_summary(_get(sm,'incident',res.get('current_incident_id')),['incident_id','title','status','severity']) if res.get('current_incident_id') else None}
if kwargs.get('include_assignment_history',True): data['assignment_history']=[a for a in sm.list_entities('resource_assignment') if a.get('resource_id')==rid][:20]
return success_response(data)
def list_shelters(state_manager=None, **kwargs):
sm=_sm(state_manager); limit=kwargs.get('limit',25); offset=kwargs.get('offset',0); sort_by=kwargs.get('sort_by','capacity_available'); sort_order=kwargs.get('sort_order','desc')
for val,allowed,code,label in [(kwargs.get('status'),SHELTER_STATUSES,'INVALID_SHELTER_STATUS','status'),(kwargs.get('supplies_status'),SUPPLIES_STATUSES,'INVALID_SUPPLIES_STATUS','supplies_status')]:
err=_enum(val,allowed,code,label)
if err: return err
if _validate_page(limit,offset): return _validate_page(limit,offset)
if kwargs.get('min_available_beds') is not None and (not isinstance(kwargs['min_available_beds'],int) or kwargs['min_available_beds']<0): return error_response('OUT_OF_RANGE','min_available_beds invalid')
if kwargs.get('operating_agency_id') and not _get(sm,'agency',kwargs['operating_agency_id']): return error_response('AGENCY_NOT_FOUND','agency missing')
if kwargs.get('active_incident_id') and not _get(sm,'incident',kwargs['active_incident_id']): return error_response('INCIDENT_NOT_FOUND','incident missing')
if sort_by not in {'name','capacity_available','updated_at'} or sort_order not in {'asc','desc'}: return error_response('INVALID_SORT','sort invalid')
rows=sm.list_entities('shelter')
for k in ['status','operating_agency_id','active_incident_id','supplies_status']:
if kwargs.get(k): rows=[r for r in rows if r.get(k)==kwargs[k]]
if kwargs.get('min_available_beds') is not None: rows=[r for r in rows if int(r.get('capacity_available') or 0)>=kwargs['min_available_beds']]
if kwargs.get('requires_pet_space',False): rows=[r for r in rows if int(r.get('pet_capacity_available') or 0)>0]
rows=_sort(rows,sort_by,sort_order); keys=['shelter_id','name','operating_agency_id','active_incident_id','status','capacity_total','capacity_available','accessible_beds','pet_capacity_available','generator_status','supplies_status']
return success_response({'total_count':len(rows),'shelters':[_summary(r,keys) for r in _page(rows,limit,offset)]})
def get_shelter_status(state_manager=None, **kwargs):
sm=_sm(state_manager); sid=kwargs.get('shelter_id')
if not is_non_empty_string(sid): return error_response('MISSING_SHELTER_ID','shelter_id is missing')
s=_get(sm,'shelter',sid)
if not s: return error_response('SHELTER_NOT_FOUND','no shelter matches shelter_id')
occ=[o for o in sm.list_entities('shelter_occupancy') if o.get('shelter_id')==sid]; active=[o for o in occ if o.get('status')=='active']
data={'shelter':s,'operating_agency':_summary(_get(sm,'agency',s.get('operating_agency_id')),['agency_id','name','agency_type']),'active_incident':_summary(_get(sm,'incident',s.get('active_incident_id')),['incident_id','title','status']) if s.get('active_incident_id') else None,'occupancy_totals':{'active_batches':len(active),'active_occupants':sum(int(o.get('occupants') or 0) for o in active),'medical_needs':sum(int(o.get('medical_needs') or 0) for o in active),'accessible_needs':sum(int(o.get('accessible_needs') or 0) for o in active),'pets':sum(int(o.get('pets') or 0) for o in active)}}
if kwargs.get('include_occupancy_breakdown',True): data['occupancy_breakdown']=occ[:20]
return success_response(data)
def list_evacuation_routes(state_manager=None, **kwargs):
sm=_sm(state_manager); limit=kwargs.get('limit',25); offset=kwargs.get('offset',0); sort_by=kwargs.get('sort_by','current_delay_minutes'); sort_order=kwargs.get('sort_order','asc')
for val,allowed,code,label in [(kwargs.get('status'),ROUTE_STATUSES,'INVALID_ROUTE_STATUS','status'),(kwargs.get('hazard_level'),HAZARD_LEVELS,'INVALID_HAZARD_LEVEL','hazard_level')]:
err=_enum(val,allowed,code,label)
if err: return err
if _validate_page(limit,offset): return _validate_page(limit,offset)
for k,ent,code in [('active_incident_id','incident','INCIDENT_NOT_FOUND'),('primary_shelter_id','shelter','SHELTER_NOT_FOUND'),('managing_agency_id','agency','AGENCY_NOT_FOUND')]:
if kwargs.get(k) and not _get(sm,ent,kwargs[k]): return error_response(code,f'{ent} missing')
if sort_by not in {'current_delay_minutes','capacity_per_hour','updated_at','name'} or sort_order not in {'asc','desc'}: return error_response('INVALID_SORT','sort invalid')
rows=sm.list_entities('evacuation_route')
for k in ['status','hazard_level','active_incident_id','primary_shelter_id','managing_agency_id']:
if kwargs.get(k): rows=[r for r in rows if r.get(k)==kwargs[k]]
if kwargs.get('origin_query'): rows=[r for r in rows if kwargs['origin_query'].lower() in r.get('origin_area','').lower()]
rows=_sort(rows,sort_by,sort_order); keys=['route_id','name','managing_agency_id','active_incident_id','primary_shelter_id','origin_area','destination_area','status','capacity_per_hour','current_delay_minutes','hazard_level','closure_reason']
return success_response({'total_count':len(rows),'routes':[_summary(r,keys) for r in _page(rows,limit,offset)]})
def search_communications(state_manager=None, **kwargs):
sm=_sm(state_manager); limit=kwargs.get('limit',25); offset=kwargs.get('offset',0)
for val,allowed,code,label in [(kwargs.get('channel'),COMM_CHANNELS,'INVALID_CHANNEL','channel'),(kwargs.get('priority'),MESSAGE_PRIORITIES,'INVALID_PRIORITY','priority')]:
err=_enum(val,allowed,code,label)
if err: return err
if _validate_page(limit,offset): return _validate_page(limit,offset)
if kwargs.get('incident_id') and not _get(sm,'incident',kwargs['incident_id']): return error_response('INCIDENT_NOT_FOUND','incident missing')
if kwargs.get('agency_id') and not _get(sm,'agency',kwargs['agency_id']): return error_response('AGENCY_NOT_FOUND','agency missing')
rows=sm.list_entities('communication_log')
if kwargs.get('incident_id'): rows=[r for r in rows if r.get('incident_id')==kwargs['incident_id']]
if kwargs.get('agency_id'): rows=[r for r in rows if r.get('sender_agency_id')==kwargs['agency_id'] or kwargs['agency_id'] in r.get('recipient_agency_ids',[])]
for k in ['channel','priority']:
if kwargs.get(k): rows=[r for r in rows if r.get(k)==kwargs[k]]
if kwargs.get('query'): rows=[r for r in rows if kwargs['query'].lower() in (r.get('subject','')+' '+r.get('message_body','')).lower()]
rows=sorted(rows,key=lambda r:r.get('sent_at') or '', reverse=True); keys=['message_id','incident_id','sender_agency_id','recipient_agency_ids','channel','subject','priority','sent_at','acknowledged_at','related_resource_id','related_shelter_id']
return success_response({'total_count':len(rows),'messages':[_summary(r,keys) for r in _page(rows,limit,offset)]})
def create_incident_report(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['title','incident_type','severity','lead_agency_id','affected_area','reported_at','public_summary'])
if err: return err
for val,allowed,code,label in [(kwargs['incident_type'],INCIDENT_TYPES,'INVALID_INCIDENT_TYPE','incident_type'),(kwargs['severity'],SEVERITIES,'INVALID_SEVERITY','severity')]:
err=_enum(val,allowed,code,label)
if err: return err
t,err=_time(kwargs['reported_at'],'INVALID_REPORTED_AT')
if err or t>datetime.now(timezone.utc): return error_response('INVALID_REPORTED_AT','reported_at is malformed or in the future')
ag=_get(sm,'agency',kwargs['lead_agency_id'])
if not ag: return error_response('AGENCY_NOT_FOUND','agency missing')
if ag.get('coordination_status')=='demobilized': return error_response('AGENCY_NOT_ACTIVE','lead agency is demobilized')
rec={'title':kwargs['title'].strip(),'incident_type':kwargs['incident_type'],'severity':kwargs['severity'],'status':'reported','priority':SEVERITY_PRIORITY[kwargs['severity']],'lead_agency_id':kwargs['lead_agency_id'],'command_post':kwargs.get('command_post') or 'EOC - Initial Desk','affected_area':kwargs['affected_area'].strip(),'reported_at':kwargs['reported_at'],'created_at':kwargs['reported_at'],'updated_at':kwargs['reported_at'],'closed_at':None,'active_resource_count':0,'sheltering_required':bool(kwargs.get('sheltering_required',False)),'evacuation_required':bool(kwargs.get('evacuation_required',False)),'public_summary':kwargs['public_summary'].strip()}
rec['incident_id']=_make_id(sm,'incident',rec); sm.add_entity('incident',rec)
return success_response({'incident_id':rec['incident_id'],'status':rec['status'],'severity':rec['severity'],'priority':rec['priority'],'lead_agency_id':rec['lead_agency_id'],'reported_at':rec['reported_at'],'created':True})
def update_incident_status(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('incident_id')): return error_response('MISSING_INCIDENT_ID','incident_id missing')
if not is_non_empty_string(kwargs.get('new_status')): return error_response('MISSING_STATUS','new_status missing')
err=_enum(kwargs['new_status'],INCIDENT_STATUSES,'INVALID_INCIDENT_STATUS','new_status')
if err: return err
inc=_get(sm,'incident',kwargs['incident_id'])
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if inc.get('status')=='closed' and kwargs['new_status']!='closed': return error_response('INCIDENT_ALREADY_CLOSED','closed incident cannot reopen')
closed_at=kwargs.get('closed_at')
if kwargs['new_status']=='closed':
t,err=_time(closed_at,'INVALID_CLOSED_AT')
if err or t < parse_iso_datetime(inc.get('reported_at')): return error_response('INVALID_CLOSED_AT','closed_at invalid')
sm.update_entity('incident',inc['incident_id'],{'status':kwargs['new_status'],'closed_at':closed_at if kwargs['new_status']=='closed' else inc.get('closed_at'),'updated_at':closed_at or now_iso()})
return success_response({'incident_id':inc['incident_id'],'previous_status':inc.get('status'),'new_status':kwargs['new_status'],'closed_at':closed_at if kwargs['new_status']=='closed' else inc.get('closed_at'),'status_note':kwargs.get('status_note')})
def assign_resource_to_incident(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['resource_id','incident_id','requested_by_agency_id','mission','priority','assigned_at'])
if err: return err
err=_enum(kwargs['priority'],ASSIGNMENT_PRIORITIES,'INVALID_PRIORITY','priority')
if err: return err
_,err=_time(kwargs['assigned_at'],'INVALID_ASSIGNMENT_TIME')
if err: return err
res=_get(sm,'resource_unit',kwargs['resource_id']); inc=_get(sm,'incident',kwargs['incident_id']); ag=_get(sm,'agency',kwargs['requested_by_agency_id'])
if not res: return error_response('RESOURCE_NOT_FOUND','resource missing')
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if not ag: return error_response('AGENCY_NOT_FOUND','agency missing')
if res.get('status') not in {'available','staged'}: return error_response('RESOURCE_NOT_AVAILABLE','resource unavailable')
if inc.get('status')=='closed': return error_response('INCIDENT_CLOSED','incident closed')
rec={'resource_id':res['resource_id'],'incident_id':inc['incident_id'],'requested_by_agency_id':ag['agency_id'],'status':'enroute' if kwargs.get('eta_at') else 'approved','mission':kwargs['mission'].strip(),'priority':kwargs['priority'],'assigned_at':kwargs['assigned_at'],'eta_at':kwargs.get('eta_at'),'arrived_at':None,'released_at':None,'notes':kwargs.get('notes') or 'Assignment created from dispatch desk.','created_at':kwargs['assigned_at'],'updated_at':kwargs['assigned_at']}
rec['assignment_id']=_make_id(sm,'resource_assignment',{**rec,'name':res['resource_id']}); sm.add_entity('resource_assignment',rec)
rstatus='enroute' if kwargs.get('eta_at') else 'assigned'; sm.update_entity('resource_unit',res['resource_id'],{'status':rstatus,'current_incident_id':inc['incident_id'],'last_status_at':kwargs['assigned_at'],'updated_at':kwargs['assigned_at']}); sm.update_entity('incident',inc['incident_id'],{'active_resource_count':int(inc.get('active_resource_count') or 0)+1,'updated_at':kwargs['assigned_at']})
return success_response({'assignment_id':rec['assignment_id'],'resource_id':res['resource_id'],'incident_id':inc['incident_id'],'status':rec['status'],'priority':rec['priority'],'assigned_at':rec['assigned_at'],'eta_at':rec['eta_at'],'resource_status':rstatus})
def release_resource_assignment(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('assignment_id')): return error_response('MISSING_ASSIGNMENT_ID','assignment_id missing')
if not is_non_empty_string(kwargs.get('released_at')): return error_response('MISSING_RELEASED_AT','released_at missing')
release_status=kwargs.get('release_status','available')
if release_status not in {'available','maintenance','out_of_service'}: return error_response('INVALID_RELEASE_STATUS','release_status invalid')
_,err=_time(kwargs['released_at'],'INVALID_RELEASE_TIME')
if err: return err
a=_get(sm,'resource_assignment',kwargs['assignment_id'])
if not a: return error_response('ASSIGNMENT_NOT_FOUND','assignment missing')
if a.get('status') not in ACTIVE_ASSIGNMENT_STATUSES: return error_response('ASSIGNMENT_NOT_ACTIVE','assignment inactive')
res=_get(sm,'resource_unit',a.get('resource_id')); inc=_get(sm,'incident',a.get('incident_id'))
if not res: return error_response('RESOURCE_NOT_FOUND','resource missing')
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
sm.update_entity('resource_assignment',a['assignment_id'],{'status':'released','released_at':kwargs['released_at'],'updated_at':kwargs['released_at']}); sm.update_entity('resource_unit',res['resource_id'],{'status':release_status,'current_incident_id':None,'last_status_at':kwargs['released_at'],'updated_at':kwargs['released_at']}); sm.update_entity('incident',inc['incident_id'],{'active_resource_count':max(0,int(inc.get('active_resource_count') or 0)-1),'updated_at':kwargs['released_at']})
return success_response({'assignment_id':a['assignment_id'],'resource_id':res['resource_id'],'incident_id':inc['incident_id'],'previous_assignment_status':a.get('status'),'new_assignment_status':'released','resource_status':release_status,'released_at':kwargs['released_at']})
def update_resource_status(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('resource_id')): return error_response('MISSING_RESOURCE_ID','resource_id missing')
if not is_non_empty_string(kwargs.get('status')): return error_response('MISSING_RESOURCE_STATUS','status missing')
if not is_non_empty_string(kwargs.get('status_at')): return error_response('MISSING_STATUS_AT','status_at missing')
err=_enum(kwargs['status'],RESOURCE_STATUSES,'INVALID_RESOURCE_STATUS','status')
if err: return err
if kwargs.get('fuel_or_supply_percent') is not None and (not isinstance(kwargs['fuel_or_supply_percent'],int) or kwargs['fuel_or_supply_percent']<0 or kwargs['fuel_or_supply_percent']>100): return error_response('OUT_OF_RANGE','fuel invalid')
_,err=_time(kwargs['status_at'],'INVALID_STATUS_TIME')
if err: return err
res=_get(sm,'resource_unit',kwargs['resource_id'])
if not res: return error_response('RESOURCE_NOT_FOUND','resource missing')
if kwargs['status'] in {'assigned','enroute'} and not res.get('current_incident_id'): return error_response('RESOURCE_INCIDENT_REQUIRED','incident required')
active=any(a.get('resource_id')==res['resource_id'] and a.get('status') in ACTIVE_ASSIGNMENT_STATUSES for a in sm.list_entities('resource_assignment'))
if kwargs['status']=='available' and active: return error_response('ACTIVE_ASSIGNMENT_CONFLICT','active assignment blocks status')
patch={'status':kwargs['status'],'last_status_at':kwargs['status_at'],'updated_at':kwargs['status_at']}
for k in ['staging_location','fuel_or_supply_percent']:
if kwargs.get(k) is not None: patch[k]=kwargs[k]
if kwargs['status'] in {'available','maintenance','out_of_service'} and not active: patch['current_incident_id']=None
upd=sm.update_entity('resource_unit',res['resource_id'],patch)
return success_response({'resource_id':res['resource_id'],'previous_status':res.get('status'),'new_status':kwargs['status'],'staging_location':upd.get('staging_location'),'fuel_or_supply_percent':upd.get('fuel_or_supply_percent'),'status_at':kwargs['status_at']})
def open_shelter_intake(state_manager=None, **kwargs):
sm=_sm(state_manager)
for field,code in [('shelter_id','MISSING_SHELTER_ID'),('incident_id','MISSING_INCIDENT_ID'),('opened_at','MISSING_OPENED_AT')]:
if not is_non_empty_string(kwargs.get(field)): return error_response(code,f'{field} missing')
supplies=kwargs.get('supplies_status','adequate')
if supplies not in SUPPLIES_STATUSES: return error_response('INVALID_SUPPLIES_STATUS','supplies_status invalid')
_,err=_time(kwargs['opened_at'],'INVALID_OPENED_AT')
if err: return err
s=_get(sm,'shelter',kwargs['shelter_id']); inc=_get(sm,'incident',kwargs['incident_id'])
if not s: return error_response('SHELTER_NOT_FOUND','shelter missing')
cap=kwargs.get('capacity_available',s.get('capacity_available'))
if not isinstance(cap,int) or cap<0 or cap>int(s.get('capacity_total') or 0): return error_response('INVALID_CAPACITY','capacity invalid')
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if inc.get('status')=='closed': return error_response('INCIDENT_CLOSED','incident closed')
if s.get('status') not in {'standby','restricted','closing','closed'}: return error_response('SHELTER_NOT_OPENABLE','shelter not openable')
sm.update_entity('shelter',s['shelter_id'],{'status':'open','active_incident_id':inc['incident_id'],'opened_at':kwargs['opened_at'],'closed_at':None,'capacity_available':cap,'supplies_status':supplies,'updated_at':kwargs['opened_at']})
return success_response({'shelter_id':s['shelter_id'],'incident_id':inc['incident_id'],'previous_status':s.get('status'),'new_status':'open','capacity_available':cap,'supplies_status':supplies,'opened_at':kwargs['opened_at']})
def register_shelter_occupancy(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['shelter_id','incident_id','intake_batch_label','occupants','checked_in_at'])
if err: return err
occupants=kwargs.get('occupants'); med=kwargs.get('medical_needs',0); acc=kwargs.get('accessible_needs',0); pets=kwargs.get('pets',0)
if not all(isinstance(x,int) for x in [occupants,med,acc,pets]) or occupants<1 or med<0 or acc<0 or pets<0 or med>occupants or acc>occupants: return error_response('OUT_OF_RANGE','counts invalid')
_,err=_time(kwargs['checked_in_at'],'INVALID_CHECKED_IN_AT')
if err: return err
s=_get(sm,'shelter',kwargs['shelter_id']); inc=_get(sm,'incident',kwargs['incident_id'])
if not s: return error_response('SHELTER_NOT_FOUND','shelter missing')
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if s.get('status') not in {'open','restricted'}: return error_response('SHELTER_NOT_ACCEPTING','shelter not accepting')
if int(s.get('capacity_available') or 0)<occupants: return error_response('INSUFFICIENT_CAPACITY','capacity insufficient')
if int(s.get('pet_capacity_available') or 0)<pets: return error_response('INSUFFICIENT_PET_CAPACITY','pet capacity insufficient')
if int(s.get('accessible_beds') or 0)<acc: return error_response('INSUFFICIENT_ACCESSIBLE_BEDS','accessible beds insufficient')
rec={'shelter_id':s['shelter_id'],'incident_id':inc['incident_id'],'intake_batch_label':kwargs['intake_batch_label'],'occupants':occupants,'medical_needs':med,'accessible_needs':acc,'pets':pets,'checked_in_at':kwargs['checked_in_at'],'checked_out_at':None,'status':'active','created_at':kwargs['checked_in_at'],'updated_at':kwargs['checked_in_at']}; rec['occupancy_id']=_make_id(sm,'shelter_occupancy',{**rec,'name':s.get('name')}); sm.add_entity('shelter_occupancy',rec)
remaining=int(s.get('capacity_available') or 0)-occupants; status='full' if remaining==0 else s.get('status')
sm.update_entity('shelter',s['shelter_id'],{'capacity_available':remaining,'pet_capacity_available':int(s.get('pet_capacity_available') or 0)-pets,'status':status,'active_incident_id':inc['incident_id'],'updated_at':kwargs['checked_in_at']})
return success_response({'occupancy_id':rec['occupancy_id'],'shelter_id':s['shelter_id'],'incident_id':inc['incident_id'],'occupants':occupants,'medical_needs':med,'accessible_needs':acc,'pets':pets,'remaining_capacity':remaining,'shelter_status':status})
def update_shelter_capacity(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('shelter_id')): return error_response('MISSING_SHELTER_ID','shelter_id missing')
fields=['capacity_total','capacity_available','accessible_beds','pet_capacity_available','generator_status','supplies_status','status']
if all(kwargs.get(k) is None for k in fields): return error_response('NO_UPDATE_FIELDS','no fields')
for val,allowed,code,label in [(kwargs.get('status'),SHELTER_STATUSES,'INVALID_SHELTER_STATUS','status'),(kwargs.get('generator_status'),GENERATOR_STATUSES,'INVALID_GENERATOR_STATUS','generator_status'),(kwargs.get('supplies_status'),SUPPLIES_STATUSES,'INVALID_SUPPLIES_STATUS','supplies_status')]:
err=_enum(val,allowed,code,label)
if err: return err
s=_get(sm,'shelter',kwargs['shelter_id'])
if not s: return error_response('SHELTER_NOT_FOUND','shelter missing')
cand=safe_copy(s)
for k in fields:
if kwargs.get(k) is not None: cand[k]=kwargs[k]
if not isinstance(cand.get('capacity_total'),int) or cand['capacity_total']<1 or not isinstance(cand.get('capacity_available'),int) or cand['capacity_available']<0 or cand['capacity_available']>cand['capacity_total'] or cand.get('accessible_beds',0)<0 or cand.get('pet_capacity_available',0)<0: return error_response('INVALID_CAPACITY','capacity invalid')
if cand.get('status')=='closed' and any(o.get('shelter_id')==s['shelter_id'] and o.get('status')=='active' for o in sm.list_entities('shelter_occupancy')): return error_response('ACTIVE_OCCUPANCY_CONFLICT','active occupancy')
if cand.get('capacity_available')==0 and kwargs.get('status') is None: cand['status']='full'
patch={k:cand[k] for k in fields if cand.get(k)!=s.get(k)}; patch['updated_at']=now_iso(); upd=sm.update_entity('shelter',s['shelter_id'],patch)
return success_response({'shelter_id':s['shelter_id'],'previous_capacity_available':s.get('capacity_available'),'capacity_available':upd.get('capacity_available'),'previous_status':s.get('status'),'status':upd.get('status'),'generator_status':upd.get('generator_status'),'supplies_status':upd.get('supplies_status')})
def close_evacuation_route(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('route_id')): return error_response('MISSING_ROUTE_ID','route_id missing')
if not is_non_empty_string(kwargs.get('closure_reason')): return error_response('MISSING_CLOSURE_REASON','closure reason missing')
if kwargs.get('status') not in {'restricted','closed'}: return error_response('INVALID_ROUTE_STATUS','route status invalid')
if kwargs.get('hazard_level') not in {'monitored','caution','blocked'}: return error_response('INVALID_HAZARD_LEVEL','hazard invalid')
delay=kwargs.get('current_delay_minutes',60)
if not isinstance(delay,int) or delay<0: return error_response('OUT_OF_RANGE','delay invalid')
_,err=_time(kwargs.get('closed_at'),'INVALID_CLOSED_AT')
if err: return err
r=_get(sm,'evacuation_route',kwargs['route_id'])
if not r: return error_response('ROUTE_NOT_FOUND','route missing')
if r.get('status')==kwargs['status'] and r.get('closure_reason')==kwargs['closure_reason']: return error_response('ROUTE_STATUS_CONFLICT','route already closed')
cap=0 if kwargs['status']=='closed' else int(r.get('capacity_per_hour') or 0)
sm.update_entity('evacuation_route',r['route_id'],{'status':kwargs['status'],'hazard_level':kwargs['hazard_level'],'closure_reason':kwargs['closure_reason'],'current_delay_minutes':delay,'capacity_per_hour':cap,'last_patrol_at':kwargs['closed_at'],'updated_at':kwargs['closed_at']})
return success_response({'route_id':r['route_id'],'previous_status':r.get('status'),'status':kwargs['status'],'hazard_level':kwargs['hazard_level'],'closure_reason':kwargs['closure_reason'],'capacity_per_hour':cap,'current_delay_minutes':delay})
def record_damage_assessment(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['incident_id','assessed_by_agency_id','area_name','damage_level','homes_affected','estimated_cost','safety_status','assessment_time','notes'])
if err: return err
for val,allowed,code,label in [(kwargs['damage_level'],DAMAGE_LEVELS,'INVALID_DAMAGE_LEVEL','damage_level'),(kwargs['safety_status'],SAFETY_STATUSES,'INVALID_SAFETY_STATUS','safety_status')]:
err=_enum(val,allowed,code,label)
if err: return err
if not isinstance(kwargs.get('homes_affected'),int) or kwargs['homes_affected']<0 or not isinstance(kwargs.get('estimated_cost'),(int,float)) or kwargs['estimated_cost']<0: return error_response('OUT_OF_RANGE','numeric values negative')
t,err=_time(kwargs['assessment_time'],'INVALID_ASSESSMENT_TIME')
if err: return err
inc=_get(sm,'incident',kwargs['incident_id']); ag=_get(sm,'agency',kwargs['assessed_by_agency_id'])
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if not ag: return error_response('AGENCY_NOT_FOUND','agency missing')
if inc.get('status')=='closed': return error_response('INCIDENT_CLOSED','incident closed')
if t < parse_iso_datetime(inc.get('reported_at')): return error_response('INVALID_ASSESSMENT_TIME','assessment before report')
first=not any(a.get('incident_id')==inc['incident_id'] for a in sm.list_entities('damage_assessment'))
rec={'incident_id':inc['incident_id'],'assessed_by_agency_id':ag['agency_id'],'area_name':kwargs['area_name'],'damage_level':kwargs['damage_level'],'homes_affected':kwargs['homes_affected'],'critical_infrastructure_affected':bool(kwargs.get('critical_infrastructure_affected',False)),'estimated_cost':float(kwargs['estimated_cost']),'safety_status':kwargs['safety_status'],'assessment_time':kwargs['assessment_time'],'notes':kwargs['notes'],'created_at':kwargs['assessment_time'],'updated_at':kwargs['assessment_time']}; rec['assessment_id']=_make_id(sm,'damage_assessment',{**rec,'name':inc.get('title')}); sm.add_entity('damage_assessment',rec); sm.update_entity('incident',inc['incident_id'],{'updated_at':kwargs['assessment_time']})
return success_response({'assessment_id':rec['assessment_id'],'incident_id':inc['incident_id'],'damage_level':rec['damage_level'],'safety_status':rec['safety_status'],'estimated_cost':rec['estimated_cost'],'first_assessment_for_incident':first})
def assign_recovery_task(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['incident_id','owner_agency_id','task_type','priority','due_at'])
if err: return err
for val,allowed,code,label in [(kwargs['task_type'],TASK_TYPES,'INVALID_TASK_TYPE','task_type'),(kwargs['priority'],TASK_PRIORITIES,'INVALID_TASK_PRIORITY','priority'),(kwargs.get('status','assigned'),{'open','assigned','in_progress','blocked'},'INVALID_TASK_STATUS','status')]:
err=_enum(val,allowed,code,label)
if err: return err
_,err=_time(kwargs['due_at'],'INVALID_DUE_AT')
if err: return err
inc=_get(sm,'incident',kwargs['incident_id']); ag=_get(sm,'agency',kwargs['owner_agency_id'])
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if not ag: return error_response('AGENCY_NOT_FOUND','agency missing')
if inc.get('status') not in {'contained','recovery','active'}: return error_response('INCIDENT_NOT_READY_FOR_RECOVERY','incident not ready')
if kwargs.get('assessment_id'):
a=_get(sm,'damage_assessment',kwargs['assessment_id'])
if not a: return error_response('ASSESSMENT_NOT_FOUND','assessment missing')
if a.get('incident_id')!=inc['incident_id']: return error_response('ASSESSMENT_INCIDENT_MISMATCH','assessment mismatch')
if kwargs.get('assigned_staff_id'):
st=_get(sm,'staff_member',kwargs['assigned_staff_id'])
if not st: return error_response('STAFF_NOT_FOUND','staff missing')
if st.get('agency_id')!=ag['agency_id']: return error_response('STAFF_AGENCY_MISMATCH','staff agency mismatch')
status=kwargs.get('status','assigned')
if status=='blocked' and not is_non_empty_string(kwargs.get('blocker_reason')): return error_response('BLOCKER_REASON_REQUIRED','blocker required')
created=now_iso(); rec={'incident_id':inc['incident_id'],'owner_agency_id':ag['agency_id'],'assessment_id':kwargs.get('assessment_id'),'task_type':kwargs['task_type'],'status':status,'priority':kwargs['priority'],'due_at':kwargs['due_at'],'assigned_staff_id':kwargs.get('assigned_staff_id'),'completed_at':None,'blocker_reason':kwargs.get('blocker_reason'),'created_at':created,'updated_at':created}; rec['task_id']=_make_id(sm,'recovery_task',{**rec,'name':inc.get('title')}); sm.add_entity('recovery_task',rec); sm.update_entity('incident',inc['incident_id'],{'updated_at':created})
return success_response({'task_id':rec['task_id'],'incident_id':inc['incident_id'],'owner_agency_id':ag['agency_id'],'task_type':rec['task_type'],'status':rec['status'],'priority':rec['priority'],'due_at':rec['due_at'],'assessment_id':rec['assessment_id'],'assigned_staff_id':rec['assigned_staff_id']})
def log_interagency_message(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['sender_agency_id','recipient_agency_ids','channel','subject','message_body','priority','sent_at'])
if err: return err
recips=kwargs.get('recipient_agency_ids')
if not isinstance(recips,list) or not recips or not all(is_non_empty_string(x) for x in recips): return error_response('INVALID_RECIPIENTS','recipients invalid')
for val,allowed,code,label in [(kwargs['channel'],COMM_CHANNELS,'INVALID_CHANNEL','channel'),(kwargs['priority'],MESSAGE_PRIORITIES,'INVALID_PRIORITY','priority')]:
err=_enum(val,allowed,code,label)
if err: return err
sent,err=_time(kwargs['sent_at'],'INVALID_MESSAGE_TIME')
if err: return err
if kwargs.get('acknowledged_at'):
ack,err=_time(kwargs['acknowledged_at'],'INVALID_MESSAGE_TIME')
if err or ack<sent: return error_response('INVALID_MESSAGE_TIME','timestamps invalid')
if not _get(sm,'agency',kwargs['sender_agency_id']): return error_response('AGENCY_NOT_FOUND','sender missing')
for r in recips:
if not _get(sm,'agency',r): return error_response('AGENCY_NOT_FOUND','recipient missing')
if kwargs.get('incident_id') and not _get(sm,'incident',kwargs['incident_id']): return error_response('INCIDENT_NOT_FOUND','incident missing')
if kwargs.get('related_resource_id') and not _get(sm,'resource_unit',kwargs['related_resource_id']): return error_response('RESOURCE_NOT_FOUND','resource missing')
if kwargs.get('related_shelter_id') and not _get(sm,'shelter',kwargs['related_shelter_id']): return error_response('SHELTER_NOT_FOUND','shelter missing')
rec={'incident_id':kwargs.get('incident_id'),'sender_agency_id':kwargs['sender_agency_id'],'recipient_agency_ids':recips,'channel':kwargs['channel'],'subject':kwargs['subject'],'message_body':kwargs['message_body'],'priority':kwargs['priority'],'sent_at':kwargs['sent_at'],'acknowledged_at':kwargs.get('acknowledged_at'),'related_resource_id':kwargs.get('related_resource_id'),'related_shelter_id':kwargs.get('related_shelter_id'),'created_at':kwargs['sent_at']}; rec['message_id']=_make_id(sm,'communication_log',{**rec,'name':rec['subject']}); sm.add_entity('communication_log',rec)
return success_response({'message_id':rec['message_id'],'incident_id':rec['incident_id'],'sender_agency_id':rec['sender_agency_id'],'recipient_agency_ids':recips,'channel':rec['channel'],'priority':rec['priority'],'sent_at':rec['sent_at'],'acknowledged':rec['acknowledged_at'] is not None})
def escalate_incident_severity(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['incident_id','new_severity','justification','updated_by_agency_id','updated_at'])
if err: return err
err=_enum(kwargs['new_severity'],SEVERITIES,'INVALID_SEVERITY','new_severity')
if err: return err
t,err=_time(kwargs['updated_at'],'INVALID_UPDATED_AT')
if err: return err
inc=_get(sm,'incident',kwargs['incident_id']); ag=_get(sm,'agency',kwargs['updated_by_agency_id'])
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if not ag: return error_response('AGENCY_NOT_FOUND','agency missing')
if inc.get('status')=='closed': return error_response('INCIDENT_CLOSED','incident closed')
if ag['agency_id']!=inc.get('lead_agency_id') and ag.get('agency_type') not in {'state','county','emergency_management'}: return error_response('PERMISSION_DENIED','permission denied')
if len(kwargs['justification'].strip())<24: return error_response('JUSTIFICATION_TOO_SHORT','justification too short')
if t < parse_iso_datetime(inc.get('reported_at')): return error_response('INVALID_UPDATED_AT','updated_at before report')
sm.update_entity('incident',inc['incident_id'],{'severity':kwargs['new_severity'],'priority':SEVERITY_PRIORITY[kwargs['new_severity']],'updated_at':kwargs['updated_at'],'public_summary':(inc.get('public_summary') or '')+' Severity update: '+kwargs['justification'].strip()})
return success_response({'incident_id':inc['incident_id'],'previous_severity':inc.get('severity'),'new_severity':kwargs['new_severity'],'previous_priority':inc.get('priority'),'new_priority':SEVERITY_PRIORITY[kwargs['new_severity']],'updated_by_agency_id':ag['agency_id'],'updated_at':kwargs['updated_at']})
def open_evacuation_route(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('route_id')): return error_response('MISSING_ROUTE_ID','route_id missing')
if not is_non_empty_string(kwargs.get('patrol_note')): return error_response('MISSING_PATROL_NOTE','patrol note missing')
if not isinstance(kwargs.get('capacity_per_hour'),int) or kwargs['capacity_per_hour']<1 or not isinstance(kwargs.get('current_delay_minutes',0),int) or kwargs.get('current_delay_minutes',0)<0: return error_response('OUT_OF_RANGE','capacity invalid')
if kwargs.get('hazard_level','clear') not in {'clear','monitored','caution'}: return error_response('INVALID_HAZARD_LEVEL','hazard invalid')
_,err=_time(kwargs.get('opened_at'),'INVALID_OPENED_AT')
if err: return err
r=_get(sm,'evacuation_route',kwargs['route_id'])
if not r: return error_response('ROUTE_NOT_FOUND','route missing')
if r.get('status') not in {'restricted','closed'}: return error_response('ROUTE_NOT_REOPENABLE','route not reopenable')
if len(kwargs['patrol_note'].strip())<20: return error_response('PATROL_NOTE_TOO_SHORT','patrol note too short')
sm.update_entity('evacuation_route',r['route_id'],{'status':'open','capacity_per_hour':kwargs['capacity_per_hour'],'current_delay_minutes':kwargs.get('current_delay_minutes',0),'hazard_level':kwargs.get('hazard_level','clear'),'closure_reason':None,'last_patrol_at':kwargs['opened_at'],'updated_at':kwargs['opened_at']})
return success_response({'route_id':r['route_id'],'previous_status':r.get('status'),'status':'open','capacity_per_hour':kwargs['capacity_per_hour'],'hazard_level':kwargs.get('hazard_level','clear'),'current_delay_minutes':kwargs.get('current_delay_minutes',0),'opened_at':kwargs['opened_at']})
def reroute_evacuee_flow(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['from_route_id','to_route_id','incident_id','expected_vehicles_per_hour','reason','rerouted_at'])
if err: return err
if kwargs['from_route_id']==kwargs['to_route_id']: return error_response('ROUTE_PAIR_CONFLICT','same route')
flow=kwargs['expected_vehicles_per_hour']
if not isinstance(flow,int) or flow<1: return error_response('OUT_OF_RANGE','flow invalid')
_,err=_time(kwargs['rerouted_at'],'INVALID_REROUTED_AT')
if err: return err
src=_get(sm,'evacuation_route',kwargs['from_route_id']); dst=_get(sm,'evacuation_route',kwargs['to_route_id']); inc=_get(sm,'incident',kwargs['incident_id'])
if not src or not dst: return error_response('ROUTE_NOT_FOUND','route missing')
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if dst.get('status') not in {'open','restricted'} or int(dst.get('capacity_per_hour') or 0)<flow: return error_response('DESTINATION_ROUTE_UNAVAILABLE','destination unavailable')
rem=max(0,int(src.get('capacity_per_hour') or 0)-flow); sstatus='closed' if rem==0 else 'restricted'; sm.update_entity('evacuation_route',src['route_id'],{'capacity_per_hour':rem,'status':sstatus,'active_incident_id':inc['incident_id'],'updated_at':kwargs['rerouted_at']}); sm.update_entity('evacuation_route',dst['route_id'],{'current_delay_minutes':int(dst.get('current_delay_minutes') or 0)+max(1,flow//100),'active_incident_id':inc['incident_id'],'updated_at':kwargs['rerouted_at']})
return success_response({'from_route_id':src['route_id'],'to_route_id':dst['route_id'],'incident_id':inc['incident_id'],'expected_vehicles_per_hour':flow,'from_route_status':sstatus,'to_route_status':dst.get('status'),'rerouted_at':kwargs['rerouted_at']})
def request_mutual_aid(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['incident_id','requester_agency_id','resource_type_requested','quantity_requested','urgency','requested_at','justification'])
if err: return err
for val,allowed,code,label in [(kwargs['resource_type_requested'],RESOURCE_TYPES,'INVALID_RESOURCE_TYPE','resource_type_requested'),(kwargs['urgency'],AID_URGENCIES,'INVALID_URGENCY','urgency')]:
err=_enum(val,allowed,code,label)
if err: return err
qty=kwargs['quantity_requested']
if not isinstance(qty,int) or qty<1 or qty>50: return error_response('OUT_OF_RANGE','quantity invalid')
_,err=_time(kwargs['requested_at'],'INVALID_REQUESTED_AT')
if err: return err
inc=_get(sm,'incident',kwargs['incident_id']); req=_get(sm,'agency',kwargs['requester_agency_id']); responder_id=kwargs.get('responder_agency_id')
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if not req or (responder_id and not _get(sm,'agency',responder_id)): return error_response('AGENCY_NOT_FOUND','agency missing')
if inc.get('status')=='closed': return error_response('INCIDENT_CLOSED','incident closed')
if responder_id==req['agency_id']: return error_response('RESPONDER_CONFLICT','same agency')
if kwargs.get('submit_now',True) and not responder_id: return error_response('RESPONDER_REQUIRED','responder required')
if len(kwargs['justification'].strip())<30: return error_response('JUSTIFICATION_TOO_SHORT','justification too short')
for a in sm.list_entities('mutual_aid_request'):
if a.get('status')=='submitted' and a.get('incident_id')==inc['incident_id'] and a.get('responder_agency_id')==responder_id and a.get('resource_type_requested')==kwargs['resource_type_requested'] and a.get('urgency')==kwargs['urgency']: return error_response('DUPLICATE_AID_REQUEST','duplicate aid')
rec={'incident_id':inc['incident_id'],'requester_agency_id':req['agency_id'],'responder_agency_id':responder_id,'resource_type_requested':kwargs['resource_type_requested'],'quantity_requested':qty,'status':'submitted' if kwargs.get('submit_now',True) else 'draft','urgency':kwargs['urgency'],'requested_at':kwargs['requested_at'],'decision_at':None,'fulfilled_at':None,'linked_assignment_id':None,'justification':kwargs['justification'],'created_at':kwargs['requested_at'],'updated_at':kwargs['requested_at']}; rec['aid_request_id']=_make_id(sm,'mutual_aid_request',{**rec,'name':inc.get('title')}); sm.add_entity('mutual_aid_request',rec); sm.update_entity('incident',inc['incident_id'],{'updated_at':kwargs['requested_at']})
return success_response({'aid_request_id':rec['aid_request_id'],'incident_id':inc['incident_id'],'requester_agency_id':req['agency_id'],'responder_agency_id':responder_id,'resource_type_requested':rec['resource_type_requested'],'quantity_requested':qty,'status':rec['status'],'urgency':rec['urgency'],'requested_at':rec['requested_at']})
def approve_mutual_aid_request(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('aid_request_id')): return error_response('MISSING_AID_REQUEST_ID','aid id missing')
if not is_non_empty_string(kwargs.get('decision')): return error_response('MISSING_DECISION','decision missing')
if kwargs['decision'] not in AID_DECISIONS: return error_response('INVALID_DECISION','decision invalid')
dec,err=_time(kwargs.get('decision_at'),'INVALID_DECISION_AT')
if err: return err
a=_get(sm,'mutual_aid_request',kwargs['aid_request_id'])
if not a: return error_response('AID_REQUEST_NOT_FOUND','aid missing')
if a.get('status')!='submitted': return error_response('AID_REQUEST_NOT_SUBMITTED','aid not submitted')
if dec < parse_iso_datetime(a.get('requested_at')): return error_response('INVALID_DECISION_AT','decision before requested')
responder_id=kwargs.get('responder_agency_id') or a.get('responder_agency_id')
if responder_id and not _get(sm,'agency',responder_id): return error_response('AGENCY_NOT_FOUND','responder missing')
if responder_id==a.get('requester_agency_id'): return error_response('RESPONDER_CONFLICT','same agency')
if kwargs['decision'] in {'approved','fulfilled'} and not responder_id: return error_response('RESPONDER_REQUIRED','responder required')
if kwargs.get('linked_assignment_id'):
ass=_get(sm,'resource_assignment',kwargs['linked_assignment_id'])
if not ass: return error_response('ASSIGNMENT_NOT_FOUND','assignment missing')
if ass.get('incident_id')!=a.get('incident_id'): return error_response('ASSIGNMENT_INCIDENT_MISMATCH','assignment mismatch')
if len(str(kwargs.get('decision_note') or '').strip())<20: return error_response('DECISION_NOTE_TOO_SHORT','decision note too short')
sm.update_entity('mutual_aid_request',a['aid_request_id'],{'status':kwargs['decision'],'decision_at':kwargs['decision_at'],'fulfilled_at':kwargs['decision_at'] if kwargs['decision']=='fulfilled' else None,'responder_agency_id':responder_id,'linked_assignment_id':kwargs.get('linked_assignment_id'),'updated_at':kwargs['decision_at']})
return success_response({'aid_request_id':a['aid_request_id'],'previous_status':a.get('status'),'new_status':kwargs['decision'],'decision':kwargs['decision'],'responder_agency_id':responder_id,'linked_assignment_id':kwargs.get('linked_assignment_id'),'decision_at':kwargs['decision_at'],'fulfilled_at':kwargs['decision_at'] if kwargs['decision']=='fulfilled' else None})
def schedule_resource_redeployment(state_manager=None, **kwargs):
sm=_sm(state_manager); err=_err_if_missing(kwargs,['current_assignment_id','target_incident_id','requested_by_agency_id','mission','priority','redeploy_at'])
if err: return err
if kwargs['priority'] not in ASSIGNMENT_PRIORITIES: return error_response('INVALID_PRIORITY','priority invalid')
_,err=_time(kwargs['redeploy_at'],'INVALID_REDEPLOY_TIME')
if err: return err
a=_get(sm,'resource_assignment',kwargs['current_assignment_id'])
if not a: return error_response('ASSIGNMENT_NOT_FOUND','assignment missing')
if a.get('status') not in ACTIVE_ASSIGNMENT_STATUSES: return error_response('ASSIGNMENT_NOT_ACTIVE','assignment inactive')
res=_get(sm,'resource_unit',a.get('resource_id'))
if not res: return error_response('RESOURCE_NOT_FOUND','resource missing')
if res.get('status') in {'maintenance','out_of_service'}: return error_response('RESOURCE_NOT_REDEPLOYABLE','resource not redeployable')
target=_get(sm,'incident',kwargs['target_incident_id']); ag=_get(sm,'agency',kwargs['requested_by_agency_id'])
if not target: return error_response('INCIDENT_NOT_FOUND','target missing')
if not ag: return error_response('AGENCY_NOT_FOUND','agency missing')
if target.get('status')=='closed': return error_response('INCIDENT_CLOSED','target closed')
if target['incident_id']==a.get('incident_id'): return error_response('SAME_INCIDENT_CONFLICT','same incident')
prev=_get(sm,'incident',a.get('incident_id')); sm.update_entity('resource_assignment',a['assignment_id'],{'status':'released','released_at':kwargs['redeploy_at'],'updated_at':kwargs['redeploy_at']})
if prev: sm.update_entity('incident',prev['incident_id'],{'active_resource_count':max(0,int(prev.get('active_resource_count') or 0)-1),'updated_at':kwargs['redeploy_at']})
rec={'resource_id':res['resource_id'],'incident_id':target['incident_id'],'requested_by_agency_id':ag['agency_id'],'status':'enroute' if kwargs.get('eta_at') else 'approved','mission':kwargs['mission'],'priority':kwargs['priority'],'assigned_at':kwargs['redeploy_at'],'eta_at':kwargs.get('eta_at'),'arrived_at':None,'released_at':None,'notes':'Resource redeployed from active assignment.','created_at':kwargs['redeploy_at'],'updated_at':kwargs['redeploy_at']}; rec['assignment_id']=_make_id(sm,'resource_assignment',{**rec,'name':res['resource_id']}); sm.add_entity('resource_assignment',rec); rstatus='enroute' if kwargs.get('eta_at') else 'assigned'; sm.update_entity('resource_unit',res['resource_id'],{'status':rstatus,'current_incident_id':target['incident_id'],'last_status_at':kwargs['redeploy_at'],'updated_at':kwargs['redeploy_at']}); sm.update_entity('incident',target['incident_id'],{'active_resource_count':int(target.get('active_resource_count') or 0)+1,'updated_at':kwargs['redeploy_at']})
return success_response({'released_assignment_id':a['assignment_id'],'new_assignment_id':rec['assignment_id'],'resource_id':res['resource_id'],'previous_incident_id':a.get('incident_id'),'target_incident_id':target['incident_id'],'resource_status':rstatus,'redeploy_at':kwargs['redeploy_at']})
def finalize_recovery_task(state_manager=None, **kwargs):
sm=_sm(state_manager)
if not is_non_empty_string(kwargs.get('task_id')): return error_response('MISSING_TASK_ID','task_id missing')
if not is_non_empty_string(kwargs.get('final_status')): return error_response('MISSING_FINAL_STATUS','final status missing')
if kwargs['final_status'] not in {'completed','cancelled'}: return error_response('INVALID_FINAL_STATUS','final status invalid')
comp,err=_time(kwargs.get('completed_at'),'INVALID_COMPLETED_AT')
if err: return err
t=_get(sm,'recovery_task',kwargs['task_id'])
if not t: return error_response('TASK_NOT_FOUND','task missing')
if t.get('status') not in OPEN_TASK_STATUSES: return error_response('TASK_NOT_FINALIZABLE','task not finalizable')
if comp < parse_iso_datetime(t.get('created_at')): return error_response('INVALID_COMPLETED_AT','completed before creation')
if len(str(kwargs.get('completion_note') or '').strip())<24: return error_response('COMPLETION_NOTE_TOO_SHORT','completion note too short')
sm.update_entity('recovery_task',t['task_id'],{'status':kwargs['final_status'],'completed_at':kwargs['completed_at'],'blocker_reason':None if kwargs['final_status']=='completed' else t.get('blocker_reason'),'updated_at':kwargs['completed_at']})
if _get(sm,'incident',t.get('incident_id')): sm.update_entity('incident',t['incident_id'],{'updated_at':kwargs['completed_at']})
return success_response({'task_id':t['task_id'],'incident_id':t.get('incident_id'),'previous_status':t.get('status'),'final_status':kwargs['final_status'],'completed_at':kwargs['completed_at'],'completion_note':kwargs['completion_note']})
def close_incident_with_recovery_check(state_manager=None, **kwargs):
sm=_sm(state_manager)
for field,code in [('incident_id','MISSING_INCIDENT_ID'),('closed_at','MISSING_CLOSED_AT'),('closure_summary','MISSING_CLOSURE_SUMMARY')]:
if not is_non_empty_string(kwargs.get(field)): return error_response(code,f'{field} missing')
closed,err=_time(kwargs['closed_at'],'INVALID_CLOSED_AT')
if err: return err
inc=_get(sm,'incident',kwargs['incident_id'])
if not inc: return error_response('INCIDENT_NOT_FOUND','incident missing')
if inc.get('status')=='closed': return error_response('INCIDENT_ALREADY_CLOSED','already closed')
if closed < parse_iso_datetime(inc.get('reported_at')): return error_response('INVALID_CLOSED_AT','closed before reported')
if any(a.get('incident_id')==inc['incident_id'] and a.get('status') in ACTIVE_ASSIGNMENT_STATUSES for a in sm.list_entities('resource_assignment')): return error_response('ACTIVE_ASSIGNMENTS_REMAIN','active assignments remain')
if any(a.get('incident_id')==inc['incident_id'] and a.get('status')=='submitted' for a in sm.list_entities('mutual_aid_request')): return error_response('PENDING_AID_REMAINS','pending aid remains')
remaining=[t for t in sm.list_entities('recovery_task') if t.get('incident_id')==inc['incident_id'] and t.get('status') in OPEN_TASK_STATUSES]
if remaining and not (kwargs.get('force_if_recovery_only') and all(t.get('priority') in {'low','normal'} for t in remaining)): return error_response('RECOVERY_TASKS_REMAIN','recovery tasks remain')
if len(kwargs['closure_summary'].strip())<40: return error_response('CLOSURE_SUMMARY_TOO_SHORT','summary too short')
sm.update_entity('incident',inc['incident_id'],{'status':'closed','closed_at':kwargs['closed_at'],'updated_at':kwargs['closed_at'],'public_summary':kwargs['closure_summary']})
return success_response({'incident_id':inc['incident_id'],'previous_status':inc.get('status'),'new_status':'closed','closed_at':kwargs['closed_at'],'shelters_closed':[],'routes_staged':[],'closure_summary':kwargs['closure_summary']})
HANDLERS={name:globals()[name] for name in TOOL_DESCRIPTIONS}
def handle_tool(tool_name: str, state_manager=None, **kwargs): return HANDLERS[tool_name](state_manager=state_manager, **kwargs)