@alexkroman1/aai-cli 5.13.2 → 6.1.0

package/dist/templates/dispatch-center/tools/incident_get.ts

@@ -1,16 +1,20 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { findIncident, getApplicableProtocols, getState, incidentAgeMinutes } from "../shared.ts";
+import {
+  dispatchSlot,
+  findIncident,
+  getApplicableProtocols,
+  incidentAgeMinutes,
+} from "../shared.ts";
 
-export const incidentGet = tool({
+export default dispatchSlot.tool({
   description: "Get full details on a specific incident including timeline and assigned resources.",
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
   }),
-  async execute(args, ctx) {
-    const state = getState(ctx);
+  execute(args, state) {
     const inc = findIncident(state, args.incidentId);
-    if ("error" in inc) return inc;
+    if (isToolFailure(inc)) return inc;
 
     const assignedResourceDetails = inc.assignedResources
       .map((rId) => {

package/dist/templates/dispatch-center/tools/incident_triage.ts

@@ -1,18 +1,18 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
 import {
   assertNotResolved,
   calculateTriageScore,
+  dispatchSlot,
   findIncident,
   getApplicableProtocols,
   INCIDENT_TYPES,
   logEvent,
   recommendResources,
   SEVERITIES,
-  updateState,
 } from "../shared.ts";
 
-export const incidentTriage = tool({
+export default dispatchSlot.updateTool({
   description:
     "Triage an incident — confirm or override severity, type, hazards, and casualty count.",
   inputSchema: z.object({
@@ -27,52 +27,50 @@ export const incidentTriage = tool({
     casualtyUpdate: z.number().int().nonnegative().describe("Updated casualty count").optional(),
     notes: z.string().max(1000).describe("Triage notes").optional(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
-      const blocked = assertNotResolved(inc, "triage");
-      if (blocked) return blocked;
+  execute(args, state) {
+    const inc = findIncident(state, args.incidentId);
+    if (isToolFailure(inc)) return inc;
+    const blocked = assertNotResolved(inc, "triage");
+    if (blocked) return blocked;
 
-      if (args.severity) inc.severity = args.severity;
-      if (args.type) inc.type = args.type;
-      for (const hazard of args.additionalHazards ?? []) {
-        if (!inc.hazards.includes(hazard)) inc.hazards.push(hazard);
-      }
-      if (args.casualtyUpdate !== undefined) {
-        inc.casualties.estimated = args.casualtyUpdate;
-      }
-      if (args.notes) logEvent(inc, `Triage note: ${args.notes}`);
+    if (args.severity) inc.severity = args.severity;
+    if (args.type) inc.type = args.type;
+    for (const hazard of args.additionalHazards ?? []) {
+      if (!inc.hazards.includes(hazard)) inc.hazards.push(hazard);
+    }
+    if (args.casualtyUpdate !== undefined) {
+      inc.casualties.estimated = args.casualtyUpdate;
+    }
+    if (args.notes) logEvent(inc, `Triage note: ${args.notes}`);
 
-      inc.triageScore = calculateTriageScore(
-        inc.severity,
-        inc.type,
-        inc.casualties.estimated,
-        inc.hazards.length,
-      );
-      inc.status = "triaged";
-      logEvent(inc, `Triaged: ${inc.severity} ${inc.type}, score ${inc.triageScore}`);
+    inc.triageScore = calculateTriageScore(
+      inc.severity,
+      inc.type,
+      inc.casualties.estimated,
+      inc.hazards.length,
+    );
+    inc.status = "triaged";
+    logEvent(inc, `Triaged: ${inc.severity} ${inc.type}, score ${inc.triageScore}`);
 
-      const protocols = getApplicableProtocols(inc.type, inc.severity);
-      const recommended = recommendResources(inc.type, inc.severity, state);
+    const protocols = getApplicableProtocols(inc.type, inc.severity);
+    const recommended = recommendResources(inc.type, inc.severity, state);
 
-      return {
-        incidentId: args.incidentId,
-        severity: inc.severity,
-        type: inc.type,
-        triageScore: inc.triageScore,
-        hazards: inc.hazards,
-        estimatedCasualties: inc.casualties.estimated,
-        protocols: protocols.map((p) => ({
-          name: p.name,
-          steps: p.steps,
-          requiredResources: p.requiredResources,
-        })),
-        recommendedResources: recommended.map((r) => ({
-          callsign: r.callsign,
-          type: r.type,
-        })),
-      };
-    });
+    return {
+      incidentId: args.incidentId,
+      severity: inc.severity,
+      type: inc.type,
+      triageScore: inc.triageScore,
+      hazards: inc.hazards,
+      estimatedCasualties: inc.casualties.estimated,
+      protocols: protocols.map((p) => ({
+        name: p.name,
+        steps: p.steps,
+        requiredResources: p.requiredResources,
+      })),
+      recommendedResources: recommended.map((r) => ({
+        callsign: r.callsign,
+        type: r.type,
+      })),
+    };
   },
 });

package/dist/templates/dispatch-center/tools/incident_update_status.ts

@@ -1,8 +1,8 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
-import { assertNotResolved, findIncident, logEvent, updateState } from "../shared.ts";
+import { assertNotResolved, dispatchSlot, findIncident, logEvent } from "../shared.ts";
 
-export const incidentUpdateStatus = tool({
+export default dispatchSlot.updateTool({
   description: "Update an incident's status (en_route, on_scene, resolved, escalated).",
   inputSchema: z.object({
     incidentId: z.string().max(20).describe("The incident ID"),
@@ -16,53 +16,51 @@ export const incidentUpdateStatus = tool({
       .describe("Updated casualty numbers")
       .optional(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
-      const blocked = assertNotResolved(inc, `set status to ${args.status}`);
-      if (blocked) return blocked;
+  execute(args, state) {
+    const inc = findIncident(state, args.incidentId);
+    if (isToolFailure(inc)) return inc;
+    const blocked = assertNotResolved(inc, `set status to ${args.status}`);
+    if (blocked) return blocked;
 
-      inc.status = args.status;
-      logEvent(inc, `Status → ${args.status}${args.notes ? `: ${args.notes}` : ""}`);
+    inc.status = args.status;
+    logEvent(inc, `Status → ${args.status}${args.notes ? `: ${args.notes}` : ""}`);
 
-      if (args.casualtyUpdate) {
-        if (args.casualtyUpdate.confirmed !== undefined) {
-          inc.casualties.confirmed = args.casualtyUpdate.confirmed;
-        }
-        if (args.casualtyUpdate.treated !== undefined) {
-          inc.casualties.treated = args.casualtyUpdate.treated;
-        }
+    if (args.casualtyUpdate) {
+      if (args.casualtyUpdate.confirmed !== undefined) {
+        inc.casualties.confirmed = args.casualtyUpdate.confirmed;
       }
+      if (args.casualtyUpdate.treated !== undefined) {
+        inc.casualties.treated = args.casualtyUpdate.treated;
+      }
+    }
 
-      // Only touch resources still assigned to THIS incident — a unit that
-      // radioed available and was re-dispatched elsewhere belongs to its
-      // new incident now.
-      const ownResources = state.resources.filter((r) => r.assignedIncident === inc.id);
+    // Only touch resources still assigned to THIS incident — a unit that
+    // radioed available and was re-dispatched elsewhere belongs to its
+    // new incident now.
+    const ownResources = state.resources.filter((r) => r.assignedIncident === inc.id);
 
-      if (args.status === "resolved") {
-        for (const r of ownResources) {
-          r.status = "returning";
-          r.assignedIncident = null;
-          r.eta = null;
-        }
-        inc.assignedResources = [];
-        logEvent(inc, "All resources released — incident closed");
+    if (args.status === "resolved") {
+      for (const r of ownResources) {
+        r.status = "returning";
+        r.assignedIncident = null;
+        r.eta = null;
       }
+      inc.assignedResources = [];
+      logEvent(inc, "All resources released — incident closed");
+    }
 
-      if (args.status === "en_route" || args.status === "on_scene") {
-        for (const r of ownResources) {
-          r.status = args.status;
-          if (args.status === "on_scene") r.eta = null;
-        }
+    if (args.status === "en_route" || args.status === "on_scene") {
+      for (const r of ownResources) {
+        r.status = args.status;
+        if (args.status === "on_scene") r.eta = null;
       }
+    }
 
-      return {
-        incidentId: args.incidentId,
-        newStatus: args.status,
-        timeline: inc.timeline.slice(-5).map((t) => t.event),
-        casualties: inc.casualties,
-      };
-    });
+    return {
+      incidentId: args.incidentId,
+      newStatus: args.status,
+      timeline: inc.timeline.slice(-5).map((t) => t.event),
+      casualties: inc.casualties,
+    };
   },
 });

package/dist/templates/dispatch-center/tools/ops_dashboard.ts

@@ -1,12 +1,9 @@
-import { tool } from "@alexkroman1/aai";
-import { getState, incidentAgeMinutes, resourceBrief, resourceUtilization } from "../shared.ts";
+import { dispatchSlot, incidentAgeMinutes, resourceBrief, resourceUtilization } from "../shared.ts";
 
-export const opsDashboard = tool({
+export default dispatchSlot.tool({
   description:
     "Get the full operational dashboard: alert level, resource utilization, active incidents, and available resources.",
-  async execute(_args, ctx) {
-    const state = getState(ctx);
-
+  execute(_args, state) {
     const activeIncidents = Object.values(state.incidents)
       .filter((i) => i.status !== "resolved")
       .sort((a, b) => b.triageScore - a.triageScore);

package/dist/templates/dispatch-center/tools/ops_protocols.ts

@@ -2,7 +2,7 @@ import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import { getApplicableProtocols, INCIDENT_TYPES, SEVERITIES } from "../shared.ts";
 
-export const opsProtocols = tool({
+export default tool({
   description: "Look up step-by-step response protocols for a given incident type and severity.",
   inputSchema: z.object({
     incidentType: z.enum(INCIDENT_TYPES).describe("Type of incident"),

package/dist/templates/dispatch-center/tools/ops_run_scenario.ts

@@ -1,7 +1,6 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
 import type { Incident, IncidentType, Severity } from "../shared.ts";
-import { calculateTriageScore, createIncident, updateState } from "../shared.ts";
+import { calculateTriageScore, createIncident, dispatchSlot } from "../shared.ts";
 
 type ScenarioIncident = Pick<Incident, "location" | "description" | "type" | "severity">;
 type ScenarioDef = { narrative: string; incidents: ScenarioIncident[] };
@@ -117,33 +116,31 @@ const scenarios = {
 type ScenarioName = keyof typeof scenarios;
 const SCENARIO_NAMES = Object.keys(scenarios) as [ScenarioName, ...ScenarioName[]];
 
-export const opsRunScenario = tool({
+export default dispatchSlot.updateTool({
   description: "Run a training scenario that creates simulated incidents for dispatch practice.",
   inputSchema: z.object({
     scenario: z.enum(SCENARIO_NAMES).describe("Scenario type to simulate"),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const s = scenarios[args.scenario];
+  execute(args, state) {
+    const s = scenarios[args.scenario];
 
-      const created: string[] = [];
-      for (const scenarioInc of s.incidents) {
-        const fullInc = createIncident(state, {
-          ...scenarioInc,
-          callerName: "Scenario",
-          callerPhone: "N/A",
-          triageScore: calculateTriageScore(scenarioInc.severity, scenarioInc.type, 0, 0),
-          timeline: [{ time: Date.now(), event: `SCENARIO: ${scenarioInc.description}` }],
-        });
-        created.push(fullInc.id);
-      }
+    const created: string[] = [];
+    for (const scenarioInc of s.incidents) {
+      const fullInc = createIncident(state, {
+        ...scenarioInc,
+        callerName: "Scenario",
+        callerPhone: "N/A",
+        triageScore: calculateTriageScore(scenarioInc.severity, scenarioInc.type, 0, 0),
+        timeline: [{ time: Date.now(), event: `SCENARIO: ${scenarioInc.description}` }],
+      });
+      created.push(fullInc.id);
+    }
 
-      return {
-        scenario: args.scenario,
-        narrative: s.narrative,
-        incidentsCreated: created,
-        message: `SCENARIO ACTIVE: ${s.narrative}. ${created.length} incidents created. Awaiting dispatch orders.`,
-      };
-    });
+    return {
+      scenario: args.scenario,
+      narrative: s.narrative,
+      incidentsCreated: created,
+      message: `SCENARIO ACTIVE: ${s.narrative}. ${created.length} incidents created. Awaiting dispatch orders.`,
+    };
   },
 });

package/dist/templates/dispatch-center/tools/resources_dispatch.ts

@@ -1,15 +1,15 @@
-import { tool } from "@alexkroman1/aai";
+import { isToolFailure } from "@alexkroman1/aai";
 import { z } from "zod";
 import type { Resource } from "../shared.ts";
 import {
   assertNotResolved,
+  dispatchSlot,
   findIncident,
   logEvent,
   recommendResources,
-  updateState,
 } from "../shared.ts";
 
-export const resourcesDispatch = tool({
+export default dispatchSlot.updateTool({
   description:
     "Dispatch units to an incident. Can auto-dispatch recommended resources or manually specify callsigns.",
   inputSchema: z.object({
@@ -30,68 +30,66 @@ export const resourcesDispatch = tool({
       .describe("Dispatch priority — affects simulated ETA")
       .optional(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const inc = findIncident(state, args.incidentId);
-      if ("error" in inc) return inc;
-      const blocked = assertNotResolved(inc, "dispatch resources");
-      if (blocked) return blocked;
+  execute(args, state) {
+    const inc = findIncident(state, args.incidentId);
+    if (isToolFailure(inc)) return inc;
+    const blocked = assertNotResolved(inc, "dispatch resources");
+    if (blocked) return blocked;
 
-      const dispatched: { callsign: string; type: string; eta: number }[] = [];
-      const failed: { callsign: string; reason: string }[] = [];
+    const dispatched: { callsign: string; type: string; eta: number }[] = [];
+    const failed: { callsign: string; reason: string }[] = [];
 
-      // The literal "auto" callsign means the same thing as autoDispatch.
-      const wantsAuto =
-        args.autoDispatch || args.callsigns?.some((cs) => cs.toLowerCase() === "auto");
+    // The literal "auto" callsign means the same thing as autoDispatch.
+    const wantsAuto =
+      args.autoDispatch || args.callsigns?.some((cs) => cs.toLowerCase() === "auto");
 
-      let resourcesToDispatch: Resource[] = [];
+    let resourcesToDispatch: Resource[] = [];
 
-      if (wantsAuto) {
-        resourcesToDispatch = recommendResources(inc.type, inc.severity, state);
-      } else if (args.callsigns) {
-        for (const cs of args.callsigns) {
-          const r = state.resources.find((r) => r.callsign.toLowerCase() === cs.toLowerCase());
-          if (!r) {
-            failed.push({ callsign: cs, reason: "Not found" });
-            continue;
-          }
-          if (r.status !== "available") {
-            failed.push({ callsign: cs, reason: `Currently ${r.status}` });
-            continue;
-          }
-          resourcesToDispatch.push(r);
+    if (wantsAuto) {
+      resourcesToDispatch = recommendResources(inc.type, inc.severity, state);
+    } else if (args.callsigns) {
+      for (const cs of args.callsigns) {
+        const r = state.resources.find((r) => r.callsign.toLowerCase() === cs.toLowerCase());
+        if (!r) {
+          failed.push({ callsign: cs, reason: "Not found" });
+          continue;
         }
+        if (r.status !== "available") {
+          failed.push({ callsign: cs, reason: `Currently ${r.status}` });
+          continue;
+        }
+        resourcesToDispatch.push(r);
       }
+    }
 
-      const etaBase = args.priority === "emergency" ? 3 : args.priority === "priority" ? 6 : 10;
+    const etaBase = args.priority === "emergency" ? 3 : args.priority === "priority" ? 6 : 10;
 
-      for (const r of resourcesToDispatch) {
-        const eta = etaBase + Math.floor(Math.random() * 5);
-        r.status = "dispatched";
-        r.assignedIncident = args.incidentId;
-        r.eta = eta;
-        inc.assignedResources.push(r.id);
-        dispatched.push({ callsign: r.callsign, type: r.type, eta });
-        logEvent(inc, `Dispatched ${r.callsign} — ETA ${eta} min`);
-      }
+    for (const r of resourcesToDispatch) {
+      const eta = etaBase + Math.floor(Math.random() * 5);
+      r.status = "dispatched";
+      r.assignedIncident = args.incidentId;
+      r.eta = eta;
+      inc.assignedResources.push(r.id);
+      dispatched.push({ callsign: r.callsign, type: r.type, eta });
+      logEvent(inc, `Dispatched ${r.callsign} — ETA ${eta} min`);
+    }
 
-      if (dispatched.length > 0) {
-        inc.status = "dispatched";
-      }
+    if (dispatched.length > 0) {
+      inc.status = "dispatched";
+    }
 
-      const availableCount = state.resources.filter((r) => r.status === "available").length;
+    const availableCount = state.resources.filter((r) => r.status === "available").length;
 
-      return {
-        incidentId: args.incidentId,
-        dispatched,
-        failed: failed.length > 0 ? failed : undefined,
-        totalAssignedToIncident: inc.assignedResources.length,
-        remainingAvailableResources: availableCount,
-        capacityWarning:
-          availableCount <= 3
-            ? "WARNING: Resource capacity critically low. Consider mutual aid."
-            : undefined,
-      };
-    });
+    return {
+      incidentId: args.incidentId,
+      dispatched,
+      failed: failed.length > 0 ? failed : undefined,
+      totalAssignedToIncident: inc.assignedResources.length,
+      remainingAvailableResources: availableCount,
+      capacityWarning:
+        availableCount <= 3
+          ? "WARNING: Resource capacity critically low. Consider mutual aid."
+          : undefined,
+    };
   },
 });

package/dist/templates/dispatch-center/tools/resources_get_available.ts

@@ -1,8 +1,7 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { getState, RESOURCE_TYPES } from "../shared.ts";
+import { dispatchSlot, RESOURCE_TYPES } from "../shared.ts";
 
-export const resourcesGetAvailable = tool({
+export default dispatchSlot.tool({
   description: "List available resources, optionally filtered by type.",
   inputSchema: z.object({
     type: z
@@ -10,8 +9,7 @@ export const resourcesGetAvailable = tool({
       .describe("Filter by resource type, or 'all'")
       .optional(),
   }),
-  async execute(args, ctx) {
-    const state = getState(ctx);
+  execute(args, state) {
     let resources = state.resources;
     if (args.type && args.type !== "all") {
       resources = resources.filter((r) => r.type === args.type);

package/dist/templates/dispatch-center/tools/resources_update_status.ts

@@ -1,62 +1,59 @@
-import { tool } from "@alexkroman1/aai";
 import { z } from "zod";
-import { logEvent, RESOURCE_STATUSES, updateState } from "../shared.ts";
+import { dispatchSlot, logEvent, RESOURCE_STATUSES } from "../shared.ts";
 
-export const resourcesUpdateStatus = tool({
+export default dispatchSlot.updateTool({
   description: "Update a resource unit's status when it radios in.",
   inputSchema: z.object({
     callsign: z.string().max(50).describe("The resource callsign"),
     status: z.enum(RESOURCE_STATUSES).describe("New status"),
     notes: z.string().max(1000).describe("Status notes").optional(),
   }),
-  async execute(args, ctx) {
-    return updateState(ctx, (state) => {
-      const resource = state.resources.find(
-        (r) => r.callsign.toLowerCase() === args.callsign.toLowerCase(),
-      );
-      if (!resource) {
-        return { error: `Resource ${args.callsign} not found` };
+  execute(args, state) {
+    const resource = state.resources.find(
+      (r) => r.callsign.toLowerCase() === args.callsign.toLowerCase(),
+    );
+    if (!resource) {
+      return { error: `Resource ${args.callsign} not found` };
+    }
+
+    const previousStatus = resource.status;
+
+    // Log to the incident timeline BEFORE unassigning, so the
+    // return-to-available transition is recorded too.
+    if (resource.assignedIncident) {
+      const inc = state.incidents[resource.assignedIncident];
+      if (inc) {
+        logEvent(
+          inc,
+          `${resource.callsign}: ${previousStatus} → ${args.status}${args.notes ? ` (${args.notes})` : ""}`,
+        );
       }
+    }
 
-      const previousStatus = resource.status;
+    resource.status = args.status;
 
-      // Log to the incident timeline BEFORE unassigning, so the
-      // return-to-available transition is recorded too.
+    if (args.status === "available") {
+      // Detach from the old incident on BOTH sides — leaving the id in
+      // assignedResources lets that incident later yank a unit that has
+      // been re-dispatched elsewhere.
       if (resource.assignedIncident) {
         const inc = state.incidents[resource.assignedIncident];
         if (inc) {
-          logEvent(
-            inc,
-            `${resource.callsign}: ${previousStatus} → ${args.status}${args.notes ? ` (${args.notes})` : ""}`,
-          );
+          inc.assignedResources = inc.assignedResources.filter((id) => id !== resource.id);
         }
       }
+      resource.assignedIncident = null;
+      resource.eta = null;
+    }
+    if (args.status === "on_scene") {
+      resource.eta = null;
+    }
 
-      resource.status = args.status;
-
-      if (args.status === "available") {
-        // Detach from the old incident on BOTH sides — leaving the id in
-        // assignedResources lets that incident later yank a unit that has
-        // been re-dispatched elsewhere.
-        if (resource.assignedIncident) {
-          const inc = state.incidents[resource.assignedIncident];
-          if (inc) {
-            inc.assignedResources = inc.assignedResources.filter((id) => id !== resource.id);
-          }
-        }
-        resource.assignedIncident = null;
-        resource.eta = null;
-      }
-      if (args.status === "on_scene") {
-        resource.eta = null;
-      }
-
-      return {
-        callsign: resource.callsign,
-        previousStatus,
-        newStatus: args.status,
-        assignedIncident: resource.assignedIncident,
-      };
-    });
+    return {
+      callsign: resource.callsign,
+      previousStatus,
+      newStatus: args.status,
+      assignedIncident: resource.assignedIncident,
+    };
   },
 });