Download cases/emergency_response/raw/mcp_servers/tool_impl.py from JoeYing/ReScopeBench: direct link, hf CLI and curl.
- Browser
- Download file 64.9 kB
-
https://huggingface.co/datasets/JoeYing/ReScopeBench/resolve/main/cases/emergency_response/raw/mcp_servers/tool_impl.py
- Command line
-
hf download hf://datasets/JoeYing/ReScopeBench/cases/emergency_response/raw/mcp_servers/tool_impl.py
-
curl -L -o tool_impl.py https://huggingface.co/datasets/JoeYing/ReScopeBench/resolve/main/cases/emergency_response/raw/mcp_servers/tool_impl.py
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) | |