@petriflow/gate 0.1.1 → 0.1.3

package/dist/index.cjs

@@ -0,0 +1,411 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  autoAdvance: () => autoAdvance,
+  classifyNets: () => classifyNets,
+  composedToolCall: () => composedToolCall,
+  createGateManager: () => createGateManager,
+  createGateState: () => createGateState,
+  defineSkillNet: () => defineSkillNet,
+  formatMarking: () => formatMarking,
+  getEnabledToolTransitions: () => getEnabledToolTransitions,
+  handleToolCall: () => handleToolCall,
+  handleToolResult: () => handleToolResult,
+  resolveTool: () => resolveTool
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types.ts
+function defineSkillNet(net) {
+  return net;
+}
+
+// src/advance.ts
+var import_engine = require("@petriflow/engine");
+function isStructural(t) {
+  return t.type === "auto" && (t.tools === void 0 || t.tools.length === 0);
+}
+function hasInputConflict(a, b, marking) {
+  for (const place of a.inputs) {
+    if (b.inputs.includes(place)) {
+      const aNeeds = a.inputs.filter((p) => p === place).length;
+      const bNeeds = b.inputs.filter((p) => p === place).length;
+      if ((marking[place] ?? 0) < aNeeds + bNeeds) return true;
+    }
+  }
+  return false;
+}
+function autoAdvance(net, marking) {
+  let current = { ...marking };
+  for (; ; ) {
+    const structural = net.transitions.filter(
+      (t) => isStructural(t) && (0, import_engine.canFire)(current, t)
+    );
+    if (structural.length === 0) break;
+    const unambiguous = structural.filter(
+      (t) => structural.every((other) => other === t || !hasInputConflict(t, other, current))
+    );
+    if (unambiguous.length === 0) break;
+    for (const t of unambiguous) {
+      if ((0, import_engine.canFire)(current, t)) {
+        current = (0, import_engine.fire)(current, t);
+      }
+    }
+  }
+  return current;
+}
+
+// src/gate.ts
+var import_engine2 = require("@petriflow/engine");
+function resolveTool(net, event) {
+  if (net.toolMapper) {
+    return net.toolMapper({
+      toolName: event.toolName,
+      input: event.input
+    });
+  }
+  return event.toolName;
+}
+function enabledToolTransitions(net, marking) {
+  return net.transitions.filter(
+    (t) => t.tools !== void 0 && t.tools.length > 0 && (0, import_engine2.canFire)(marking, t)
+  );
+}
+function getEnabledToolTransitions(net, marking) {
+  return enabledToolTransitions(net, marking);
+}
+function formatMarking(marking) {
+  return Object.entries(marking).filter(([, v]) => v > 0).map(([k, v]) => `${k}:${v}`).join(", ");
+}
+function createGateState(marking) {
+  return { marking, meta: {}, pending: /* @__PURE__ */ new Map() };
+}
+async function handleToolCall(event, ctx, net, state) {
+  const resolvedTool = resolveTool(net, event);
+  if (net.freeTools.includes(resolvedTool)) {
+    return void 0;
+  }
+  const enabled = enabledToolTransitions(net, state.marking);
+  const matching = enabled.filter((t) => t.tools.includes(resolvedTool));
+  if (matching.length === 0) {
+    return {
+      block: true,
+      reason: `Tool '${resolvedTool}' not available in current state. Marking: ${formatMarking(state.marking)}`
+    };
+  }
+  const transition = matching[0];
+  if (net.validateToolCall) {
+    const rejection = net.validateToolCall(
+      { toolName: event.toolName, input: event.input },
+      resolvedTool,
+      transition,
+      state
+    );
+    if (rejection) return rejection;
+  }
+  if (transition.type === "manual") {
+    if (!ctx.hasUI) {
+      return { block: true, reason: `Manual transition '${transition.name}' requires UI approval` };
+    }
+    const approved = await ctx.confirm(
+      `Approve: ${transition.name}`,
+      `Allow '${resolvedTool}' via transition '${transition.name}'?`
+    );
+    if (!approved) {
+      return { block: true, reason: `Human rejected '${transition.name}'` };
+    }
+  }
+  if (transition.deferred) {
+    state.pending.set(event.toolCallId, { toolCallId: event.toolCallId, transition, resolvedTool });
+    return void 0;
+  }
+  state.marking = (0, import_engine2.fire)(state.marking, transition);
+  state.marking = autoAdvance(net, state.marking);
+  return void 0;
+}
+function handleToolResult(event, net, state) {
+  const pending = state.pending.get(event.toolCallId);
+  if (!pending) return;
+  state.pending.delete(event.toolCallId);
+  if (event.isError) {
+    return;
+  }
+  if ((0, import_engine2.canFire)(state.marking, pending.transition)) {
+    state.marking = (0, import_engine2.fire)(state.marking, pending.transition);
+    if (net.onDeferredResult) {
+      net.onDeferredResult(
+        {
+          toolCallId: event.toolCallId,
+          input: event.input,
+          isError: event.isError
+        },
+        pending.resolvedTool,
+        pending.transition,
+        state
+      );
+    }
+    state.marking = autoAdvance(net, state.marking);
+  }
+}
+
+// src/compose.ts
+var import_engine3 = require("@petriflow/engine");
+function hasJurisdiction(net, resolvedTool) {
+  return net.transitions.some(
+    (t) => t.tools !== void 0 && t.tools.includes(resolvedTool)
+  );
+}
+function classifyNets(nets, states, event) {
+  return nets.map((net, i) => {
+    const state = states[i];
+    const resolvedTool = resolveTool(net, event);
+    const base = { net, state, resolvedTool };
+    if (net.freeTools.includes(resolvedTool)) {
+      return { ...base, kind: "free" };
+    }
+    if (!hasJurisdiction(net, resolvedTool)) {
+      return { ...base, kind: "abstain" };
+    }
+    const enabled = getEnabledToolTransitions(net, state.marking);
+    const matching = enabled.filter((t) => t.tools.includes(resolvedTool));
+    if (matching.length === 0) {
+      return {
+        ...base,
+        kind: "blocked",
+        reason: `[${net.name}] Tool '${resolvedTool}' not available in current state. Marking: ${formatMarking(state.marking)}`
+      };
+    }
+    return { ...base, kind: "gated", transition: matching[0] };
+  });
+}
+async function composedToolCall(getNets, getStates, event, ctx) {
+  const nets = getNets();
+  const states = getStates();
+  const verdicts = classifyNets(nets, states, {
+    toolName: event.toolName,
+    input: event.input
+  });
+  const blocked = verdicts.find((v) => v.kind === "blocked");
+  if (blocked) {
+    return { block: true, reason: blocked.reason };
+  }
+  const gated = verdicts.filter(
+    (v) => v.kind === "gated"
+  );
+  if (gated.length === 0) {
+    return void 0;
+  }
+  for (const v of gated) {
+    if (v.transition.type === "manual") {
+      if (!ctx.hasUI) {
+        return {
+          block: true,
+          reason: `[${v.net.name}] Manual transition '${v.transition.name}' requires UI approval`
+        };
+      }
+      const approved = await ctx.confirm(
+        `Approve: ${v.transition.name} (${v.net.name})`,
+        `Allow '${v.resolvedTool}' via transition '${v.transition.name}' in net '${v.net.name}'?`
+      );
+      if (!approved) {
+        return {
+          block: true,
+          reason: `[${v.net.name}] Human rejected '${v.transition.name}'`
+        };
+      }
+    }
+  }
+  const metaSnapshots = gated.map((v) => structuredClone(v.state.meta));
+  for (let i = 0; i < gated.length; i++) {
+    const v = gated[i];
+    if (v.net.validateToolCall) {
+      const rejection = v.net.validateToolCall(
+        { toolName: event.toolName, input: event.input },
+        v.resolvedTool,
+        v.transition,
+        v.state
+      );
+      if (rejection) {
+        for (let j = 0; j < i; j++) {
+          gated[j].state.meta = metaSnapshots[j];
+        }
+        return rejection;
+      }
+    }
+  }
+  for (const v of gated) {
+    if (v.transition.deferred) {
+      v.state.pending.set(event.toolCallId, {
+        toolCallId: event.toolCallId,
+        transition: v.transition,
+        resolvedTool: v.resolvedTool
+      });
+    } else {
+      v.state.marking = (0, import_engine3.fire)(v.state.marking, v.transition);
+      v.state.marking = autoAdvance(v.net, v.state.marking);
+    }
+  }
+  return void 0;
+}
+
+// src/manager.ts
+function createGateManager(input, opts) {
+  const manager = Array.isArray(input) ? createArrayManager(input) : createRegistryManager(input);
+  if (opts) {
+    const original = manager.handleToolCall;
+    manager.handleToolCall = async (event, ctx) => {
+      const decision = await original.call(manager, event, ctx);
+      opts.onDecision?.(event, decision);
+      if (opts.mode === "shadow" && decision?.block) {
+        return void 0;
+      }
+      return decision;
+    };
+  }
+  return manager;
+}
+function createArrayManager(nets) {
+  const states = nets.map(
+    (net) => createGateState(autoAdvance(net, { ...net.initialMarking }))
+  );
+  const getNets = () => nets;
+  const getStates = () => states;
+  return {
+    handleToolCall(event, ctx) {
+      return composedToolCall(getNets, getStates, event, ctx);
+    },
+    handleToolResult(event) {
+      for (let i = 0; i < nets.length; i++) {
+        handleToolResult(event, nets[i], states[i]);
+      }
+    },
+    addNet() {
+      return { ok: false, message: "Static composition does not support dynamic nets" };
+    },
+    removeNet() {
+      return { ok: false, message: "Static composition does not support dynamic nets" };
+    },
+    getActiveNets() {
+      return nets.map((net, i) => ({ name: net.name, net, state: states[i] }));
+    },
+    getAllNets() {
+      return nets.map((net, i) => ({ name: net.name, net, state: states[i], active: true }));
+    },
+    formatStatus() {
+      return nets.map((n, i) => `${n.name}: ${formatMarking(states[i].marking)}`).join("\n");
+    },
+    formatSystemPrompt() {
+      return formatPromptForNets(nets, states);
+    },
+    isDynamic: false
+  };
+}
+function createRegistryManager(config) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const [name, net] of Object.entries(config.registry)) {
+    registry.set(name, {
+      net,
+      state: createGateState(autoAdvance(net, { ...net.initialMarking }))
+    });
+  }
+  const activeNames = new Set(config.active ?? Object.keys(config.registry));
+  const getActiveNets = () => [...activeNames].map((n) => registry.get(n).net);
+  const getActiveStates = () => [...activeNames].map((n) => registry.get(n).state);
+  return {
+    handleToolCall(event, ctx) {
+      return composedToolCall(getActiveNets, getActiveStates, event, ctx);
+    },
+    handleToolResult(event) {
+      for (const { net, state } of registry.values()) {
+        handleToolResult(event, net, state);
+      }
+    },
+    addNet(name) {
+      if (!registry.has(name)) {
+        return { ok: false, message: `Unknown net '${name}'. Available: ${[...registry.keys()].join(", ")}` };
+      }
+      if (activeNames.has(name)) {
+        return { ok: false, message: `'${name}' is already active` };
+      }
+      activeNames.add(name);
+      return { ok: true, message: `Activated '${name}'` };
+    },
+    removeNet(name) {
+      if (!activeNames.has(name)) {
+        return { ok: false, message: `'${name}' is not active. Active: ${[...activeNames].join(", ")}` };
+      }
+      activeNames.delete(name);
+      return { ok: true, message: `Deactivated '${name}' (state preserved)` };
+    },
+    getActiveNets() {
+      return [...activeNames].map((name) => {
+        const entry = registry.get(name);
+        return { name, net: entry.net, state: entry.state };
+      });
+    },
+    getAllNets() {
+      return [...registry.entries()].map(([name, { net, state }]) => ({
+        name,
+        net,
+        state,
+        active: activeNames.has(name)
+      }));
+    },
+    formatStatus() {
+      return [...registry.entries()].map(([name, { state }]) => {
+        const status = activeNames.has(name) ? "active" : "inactive";
+        return `${name} (${status}): ${formatMarking(state.marking)}`;
+      }).join("\n");
+    },
+    formatSystemPrompt() {
+      return formatPromptForNets(getActiveNets(), getActiveStates());
+    },
+    isDynamic: true
+  };
+}
+function formatPromptForNets(nets, states) {
+  const sections = nets.map((net, i) => {
+    const enabled = getEnabledToolTransitions(net, states[i].marking);
+    const toolList = enabled.flatMap((t) => t.tools ?? []);
+    return `### ${net.name}
+Available gated tools: ${toolList.join(", ") || "none"}
+Free tools: ${net.freeTools.join(", ")}
+State: ${formatMarking(states[i].marking)}`;
+  });
+  return `## Active Petri Nets (composed)
+${sections.join("\n\n")}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  autoAdvance,
+  classifyNets,
+  composedToolCall,
+  createGateManager,
+  createGateState,
+  defineSkillNet,
+  formatMarking,
+  getEnabledToolTransitions,
+  handleToolCall,
+  handleToolResult,
+  resolveTool
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts","../src/types.ts","../src/advance.ts","../src/gate.ts","../src/compose.ts","../src/manager.ts"],"sourcesContent":["// Types\nexport { defineSkillNet } from \"./types.js\";\nexport type { SkillNet, GatedTransition, ToolEvent } from \"./types.js\";\n\n// Generic event types\nexport type { GateToolCall, GateToolResult, GateContext, GateDecision } from \"./events.js\";\n\n// Auto-advance\nexport { autoAdvance } from \"./advance.js\";\n\n// Single-net gating\nexport {\n  handleToolCall,\n  handleToolResult,\n  formatMarking,\n  getEnabledToolTransitions,\n  createGateState,\n  resolveTool,\n} from \"./gate.js\";\nexport type { GateState } from \"./gate.js\";\n\n// Multi-net composition\nexport { classifyNets, composedToolCall } from \"./compose.js\";\nexport type { ComposeConfig, NetVerdict } from \"./compose.js\";\n\n// Manager\nexport { createGateManager } from \"./manager.js\";\nexport type { GateManager, GateManagerOptions } from \"./manager.js\";\n","import type { Marking } from \"@petriflow/engine\";\n\n/** A transition that optionally gates tool access */\nexport type GatedTransition<Place extends string> = {\n  name: string;\n  type: \"auto\" | \"manual\";\n  inputs: Place[];\n  outputs: Place[];\n  guard?: string | null;\n  tools?: string[];\n  /**\n   * When true, the transition allows the tool call immediately but\n   * only fires (consumes/produces tokens) when the tool_result\n   * comes back successfully (isError === false).\n   * Use this for transitions where the tool must succeed before\n   * the net advances (e.g. backup must succeed before delete unlocks).\n   */\n  deferred?: boolean;\n};\n\n/** Minimal tool event shape for toolMapper */\nexport type ToolEvent = { toolName: string; input: Record<string, unknown> };\n\n/** A Petri net that gates a skill's tool access */\nexport type SkillNet<Place extends string> = {\n  name: string;\n  places: Place[];\n  transitions: GatedTransition<Place>[];\n  initialMarking: Marking<Place>;\n  terminalPlaces: Place[];\n  freeTools: string[];\n  /**\n   * Maps a tool call to a virtual tool name before gating.\n   * Use this to split one tool (e.g. \"bash\") into multiple gated\n   * variants (e.g. \"bash\", \"git-commit\", \"git-push\") based on input.\n   * If not provided, event.toolName is used as-is.\n   */\n  toolMapper?: (event: ToolEvent) => string;\n  /**\n   * Additional validation before a gated tool call is allowed.\n   * Called after the net confirms a matching transition exists.\n   * Return { block, reason } to reject, or void to allow.\n   * Use this for domain-specific checks (e.g. path coverage).\n   *\n   * Method syntax is intentional — bivariant so SkillNet<Place> widens to SkillNet<string>.\n   */\n  validateToolCall?(\n    event: ToolEvent,\n    resolvedTool: string,\n    transition: GatedTransition<Place>,\n    state: { marking: Marking<Place>; meta: Record<string, unknown> },\n  ): { block: true; reason: string } | void;\n  /**\n   * Called when a deferred transition's tool_result arrives.\n   * Use this to record metadata (e.g. backed-up paths).\n   *\n   * Method syntax is intentional — bivariant so SkillNet<Place> widens to SkillNet<string>.\n   */\n  onDeferredResult?(\n    event: { toolCallId: string; input: Record<string, unknown>; isError: boolean },\n    resolvedTool: string,\n    transition: GatedTransition<Place>,\n    state: { marking: Marking<Place>; meta: Record<string, unknown> },\n  ): void;\n};\n\n/** Type-safe helper — validates places/marking at the type level */\nexport function defineSkillNet<Place extends string>(\n  net: SkillNet<Place>,\n): SkillNet<Place> {\n  return net;\n}\n","import { canFire, fire } from \"@petriflow/engine\";\nimport type { Marking } from \"@petriflow/engine\";\nimport type { GatedTransition, SkillNet } from \"./types.js\";\n\n/** A structural transition: type=auto, no tools property */\nfunction isStructural<P extends string>(t: GatedTransition<P>): boolean {\n  return t.type === \"auto\" && (t.tools === undefined || t.tools.length === 0);\n}\n\n/**\n * Check if two transitions compete for the same input token.\n * Two transitions conflict if they share an input place and the\n * marking doesn't have enough tokens for both.\n */\nfunction hasInputConflict<P extends string>(\n  a: GatedTransition<P>,\n  b: GatedTransition<P>,\n  marking: Marking<P>,\n): boolean {\n  for (const place of a.inputs) {\n    if (b.inputs.includes(place)) {\n      // Count how many tokens each needs from this place\n      const aNeeds = a.inputs.filter((p) => p === place).length;\n      const bNeeds = b.inputs.filter((p) => p === place).length;\n      if ((marking[place] ?? 0) < aNeeds + bNeeds) return true;\n    }\n  }\n  return false;\n}\n\n/**\n * Auto-advance: fire all enabled structural transitions (type=auto,\n * no tools) in a loop until quiescent.\n *\n * When multiple structural transitions compete for the same input\n * token, none of them fire (avoids ambiguous choices).\n */\nexport function autoAdvance<P extends string>(\n  net: SkillNet<P>,\n  marking: Marking<P>,\n): Marking<P> {\n  let current = { ...marking };\n\n  for (;;) {\n    const structural = net.transitions.filter(\n      (t) => isStructural(t) && canFire(current, t),\n    );\n    if (structural.length === 0) break;\n\n    // Filter out transitions that conflict with another enabled one\n    const unambiguous = structural.filter((t) =>\n      structural.every((other) => other === t || !hasInputConflict(t, other, current)),\n    );\n    if (unambiguous.length === 0) break;\n\n    for (const t of unambiguous) {\n      // Re-check enablement — earlier firings in this batch may have consumed tokens\n      if (canFire(current, t)) {\n        current = fire(current, t);\n      }\n    }\n  }\n\n  return current;\n}\n","import { canFire, fire } from \"@petriflow/engine\";\nimport type { Marking } from \"@petriflow/engine\";\nimport type { GateToolCall, GateToolResult, GateContext, GateDecision } from \"./events.js\";\nimport type { GatedTransition, SkillNet } from \"./types.js\";\nimport { autoAdvance } from \"./advance.js\";\n\n/** Resolve the virtual tool name for a tool call event */\nexport function resolveTool<P extends string>(\n  net: SkillNet<P>,\n  event: { toolName: string; input: Record<string, unknown> },\n): string {\n  if (net.toolMapper) {\n    return net.toolMapper({\n      toolName: event.toolName,\n      input: event.input,\n    });\n  }\n  return event.toolName;\n}\n\n/** Return transitions that are structurally enabled and have a tools list */\nfunction enabledToolTransitions<P extends string>(\n  net: SkillNet<P>,\n  marking: Marking<P>,\n): GatedTransition<P>[] {\n  return net.transitions.filter(\n    (t) => t.tools !== undefined && t.tools.length > 0 && canFire(marking, t),\n  );\n}\n\n/** Public: get tool transitions the agent can currently use */\nexport function getEnabledToolTransitions<P extends string>(\n  net: SkillNet<P>,\n  marking: Marking<P>,\n): GatedTransition<P>[] {\n  return enabledToolTransitions(net, marking);\n}\n\n/** Format marking for display */\nexport function formatMarking<P extends string>(marking: Marking<P>): string {\n  return Object.entries(marking)\n    .filter(([, v]) => (v as number) > 0)\n    .map(([k, v]) => `${k}:${v}`)\n    .join(\", \");\n}\n\n/** A pending deferred transition awaiting tool_result */\ntype PendingDeferred<P extends string> = {\n  toolCallId: string;\n  transition: GatedTransition<P>;\n  resolvedTool: string;\n};\n\nexport type GateState<P extends string> = {\n  marking: Marking<P>;\n  /** Skill-specific metadata (e.g. backed-up paths) */\n  meta: Record<string, unknown>;\n  /** Deferred transitions waiting for tool_result */\n  pending: Map<string, PendingDeferred<P>>;\n};\n\nexport function createGateState<P extends string>(marking: Marking<P>): GateState<P> {\n  return { marking, meta: {}, pending: new Map() };\n}\n\n/**\n * Core gating logic for a tool_call event.\n * Mutates state.marking when a non-deferred transition fires.\n * For deferred transitions, records pending and fires on tool_result.\n */\nexport async function handleToolCall<P extends string>(\n  event: GateToolCall,\n  ctx: GateContext,\n  net: SkillNet<P>,\n  state: GateState<P>,\n): Promise<GateDecision> {\n  const resolvedTool = resolveTool(net, event);\n\n  // Free tools always pass\n  if (net.freeTools.includes(resolvedTool)) {\n    return undefined;\n  }\n\n  const enabled = enabledToolTransitions(net, state.marking);\n  const matching = enabled.filter((t) => t.tools!.includes(resolvedTool));\n\n  if (matching.length === 0) {\n    return {\n      block: true,\n      reason: `Tool '${resolvedTool}' not available in current state. Marking: ${formatMarking(state.marking)}`,\n    };\n  }\n\n  const transition = matching[0]!;\n\n  // Skill-specific validation (e.g. path coverage)\n  if (net.validateToolCall) {\n    const rejection = net.validateToolCall(\n      { toolName: event.toolName, input: event.input },\n      resolvedTool,\n      transition,\n      state,\n    );\n    if (rejection) return rejection;\n  }\n\n  if (transition.type === \"manual\") {\n    if (!ctx.hasUI) {\n      return { block: true, reason: `Manual transition '${transition.name}' requires UI approval` };\n    }\n    const approved = await ctx.confirm(\n      `Approve: ${transition.name}`,\n      `Allow '${resolvedTool}' via transition '${transition.name}'?`,\n    );\n    if (!approved) {\n      return { block: true, reason: `Human rejected '${transition.name}'` };\n    }\n  }\n\n  if (transition.deferred) {\n    // Allow the tool call but don't fire yet — wait for tool_result\n    state.pending.set(event.toolCallId, { toolCallId: event.toolCallId, transition, resolvedTool });\n    return undefined;\n  }\n\n  // Fire immediately\n  state.marking = fire(state.marking, transition);\n  state.marking = autoAdvance(net, state.marking);\n\n  return undefined;\n}\n\n/**\n * Handle a tool_result event. Fires deferred transitions on success.\n * Returns void (tool_result handler doesn't block).\n */\nexport function handleToolResult<P extends string>(\n  event: GateToolResult,\n  net: SkillNet<P>,\n  state: GateState<P>,\n): void {\n  const pending = state.pending.get(event.toolCallId);\n  if (!pending) return;\n\n  state.pending.delete(event.toolCallId);\n\n  if (event.isError) {\n    // Tool failed — don't fire the transition, marking unchanged\n    return;\n  }\n\n  // Tool succeeded — fire the deferred transition\n  if (canFire(state.marking, pending.transition)) {\n    state.marking = fire(state.marking, pending.transition);\n\n    // Notify the skill of the successful deferred result\n    if (net.onDeferredResult) {\n      net.onDeferredResult(\n        {\n          toolCallId: event.toolCallId,\n          input: event.input,\n          isError: event.isError,\n        },\n        pending.resolvedTool,\n        pending.transition,\n        state,\n      );\n    }\n\n    state.marking = autoAdvance(net, state.marking);\n  }\n}\n","import { fire } from \"@petriflow/engine\";\nimport type { GateToolCall, GateContext, GateDecision } from \"./events.js\";\nimport type { SkillNet } from \"./types.js\";\nimport { autoAdvance } from \"./advance.js\";\nimport {\n  formatMarking,\n  getEnabledToolTransitions,\n  resolveTool,\n} from \"./gate.js\";\nimport type { GateState } from \"./gate.js\";\n\n/** Classification of a net's opinion on a tool call */\nexport type NetVerdict<P extends string> = {\n  net: SkillNet<P>;\n  state: GateState<P>;\n  resolvedTool: string;\n} & (\n  | { kind: \"free\" }\n  | { kind: \"abstain\" }\n  | { kind: \"blocked\"; reason: string }\n  | { kind: \"gated\"; transition: SkillNet<P>[\"transitions\"][number] }\n);\n\n/** Registry-based config for dynamic net management */\nexport type ComposeConfig = {\n  registry: Record<string, SkillNet<string>>;\n  active?: string[];\n};\n\n/**\n * Check if a net has jurisdiction over a tool — i.e. the tool appears\n * in at least one transition's tools list (enabled or not).\n */\nfunction hasJurisdiction<P extends string>(\n  net: SkillNet<P>,\n  resolvedTool: string,\n): boolean {\n  return net.transitions.some(\n    (t) => t.tools !== undefined && t.tools.includes(resolvedTool),\n  );\n}\n\n/**\n * Phase 1 — Structural check (non-mutating).\n * Classify each net as free, gated, blocked, or abstain.\n */\nexport function classifyNets<P extends string>(\n  nets: SkillNet<P>[],\n  states: GateState<P>[],\n  event: { toolName: string; input: Record<string, unknown> },\n): NetVerdict<P>[] {\n  return nets.map((net, i) => {\n    const state = states[i]!;\n    const resolvedTool = resolveTool(net, event);\n    const base = { net, state, resolvedTool };\n\n    // Free tools always pass\n    if (net.freeTools.includes(resolvedTool)) {\n      return { ...base, kind: \"free\" as const };\n    }\n\n    // No jurisdiction → abstain\n    if (!hasJurisdiction(net, resolvedTool)) {\n      return { ...base, kind: \"abstain\" as const };\n    }\n\n    // Has jurisdiction — check enabled transitions\n    const enabled = getEnabledToolTransitions(net, state.marking);\n    const matching = enabled.filter((t) => t.tools!.includes(resolvedTool));\n\n    if (matching.length === 0) {\n      return {\n        ...base,\n        kind: \"blocked\" as const,\n        reason: `[${net.name}] Tool '${resolvedTool}' not available in current state. Marking: ${formatMarking(state.marking)}`,\n      };\n    }\n\n    return { ...base, kind: \"gated\" as const, transition: matching[0]! };\n  });\n}\n\n/**\n * 4-phase tool call handler for composed nets.\n */\nexport async function composedToolCall(\n  getNets: () => SkillNet<string>[],\n  getStates: () => GateState<string>[],\n  event: GateToolCall,\n  ctx: GateContext,\n): Promise<GateDecision> {\n  const nets = getNets();\n  const states = getStates();\n\n  // --- Phase 1: Structural check ---\n  const verdicts = classifyNets(nets, states, {\n    toolName: event.toolName,\n    input: event.input,\n  });\n\n  // If any net blocks, reject immediately\n  const blocked = verdicts.find((v) => v.kind === \"blocked\");\n  if (blocked) {\n    return { block: true, reason: blocked.reason };\n  }\n\n  const gated = verdicts.filter(\n    (v): v is Extract<NetVerdict<string>, { kind: \"gated\" }> => v.kind === \"gated\",\n  );\n\n  // No gated nets → all free/abstain → allow\n  if (gated.length === 0) {\n    return undefined;\n  }\n\n  // --- Phase 2: Manual approvals ---\n  for (const v of gated) {\n    if (v.transition.type === \"manual\") {\n      if (!ctx.hasUI) {\n        return {\n          block: true,\n          reason: `[${v.net.name}] Manual transition '${v.transition.name}' requires UI approval`,\n        };\n      }\n      const approved = await ctx.confirm(\n        `Approve: ${v.transition.name} (${v.net.name})`,\n        `Allow '${v.resolvedTool}' via transition '${v.transition.name}' in net '${v.net.name}'?`,\n      );\n      if (!approved) {\n        return {\n          block: true,\n          reason: `[${v.net.name}] Human rejected '${v.transition.name}'`,\n        };\n      }\n    }\n  }\n\n  // --- Phase 3: Semantic validation with meta rollback ---\n  // Snapshot all meta for rollback\n  const metaSnapshots = gated.map((v) => structuredClone(v.state.meta));\n\n  for (let i = 0; i < gated.length; i++) {\n    const v = gated[i]!;\n    if (v.net.validateToolCall) {\n      const rejection = v.net.validateToolCall(\n        { toolName: event.toolName, input: event.input },\n        v.resolvedTool,\n        v.transition,\n        v.state,\n      );\n      if (rejection) {\n        // Rollback all meta that may have been mutated by earlier validates\n        for (let j = 0; j < i; j++) {\n          gated[j]!.state.meta = metaSnapshots[j]!;\n        }\n        return rejection;\n      }\n    }\n  }\n\n  // --- Phase 4: Commit ---\n  for (const v of gated) {\n    if (v.transition.deferred) {\n      v.state.pending.set(event.toolCallId, {\n        toolCallId: event.toolCallId,\n        transition: v.transition,\n        resolvedTool: v.resolvedTool,\n      });\n    } else {\n      v.state.marking = fire(v.state.marking, v.transition);\n      v.state.marking = autoAdvance(v.net, v.state.marking);\n    }\n  }\n\n  return undefined;\n}\n","import type { GateToolCall, GateToolResult, GateContext, GateDecision } from \"./events.js\";\nimport type { SkillNet } from \"./types.js\";\nimport type { GateState } from \"./gate.js\";\nimport {\n  createGateState,\n  formatMarking,\n  getEnabledToolTransitions,\n  handleToolResult as handleToolResultSingle,\n} from \"./gate.js\";\nimport { autoAdvance } from \"./advance.js\";\nimport { composedToolCall } from \"./compose.js\";\nimport type { ComposeConfig } from \"./compose.js\";\n\nexport type GateManager = {\n  handleToolCall: (event: GateToolCall, ctx: GateContext) => Promise<GateDecision>;\n  handleToolResult: (event: GateToolResult) => void;\n  addNet: (name: string) => { ok: boolean; message: string };\n  removeNet: (name: string) => { ok: boolean; message: string };\n  getActiveNets: () => Array<{ name: string; net: SkillNet<string>; state: GateState<string> }>;\n  getAllNets: () => Array<{ name: string; net: SkillNet<string>; state: GateState<string>; active: boolean }>;\n  formatStatus: () => string;\n  formatSystemPrompt: () => string;\n  isDynamic: boolean;\n};\n\nexport type GateManagerOptions = {\n  /** \"enforce\" blocks disallowed tools. \"shadow\" logs but never blocks. */\n  mode: \"enforce\" | \"shadow\";\n  /** Called after every gating decision. Use for logging, metrics, debugging. */\n  onDecision?: (event: GateToolCall, decision: GateDecision) => void;\n};\n\nexport function createGateManager(input: SkillNet<string>[] | ComposeConfig, opts?: GateManagerOptions): GateManager {\n  const manager = Array.isArray(input) ? createArrayManager(input) : createRegistryManager(input);\n\n  if (opts) {\n    const original = manager.handleToolCall;\n    manager.handleToolCall = async (event, ctx) => {\n      const decision = await original.call(manager, event, ctx);\n      opts.onDecision?.(event, decision);\n      if (opts.mode === \"shadow\" && decision?.block) {\n        return undefined;\n      }\n      return decision;\n    };\n  }\n\n  return manager;\n}\n\nfunction createArrayManager(nets: SkillNet<string>[]): GateManager {\n  const states = nets.map((net) =>\n    createGateState(autoAdvance(net, { ...net.initialMarking })),\n  );\n\n  const getNets = () => nets;\n  const getStates = () => states;\n\n  return {\n    handleToolCall(event, ctx) {\n      return composedToolCall(getNets, getStates, event, ctx);\n    },\n\n    handleToolResult(event) {\n      for (let i = 0; i < nets.length; i++) {\n        handleToolResultSingle(event, nets[i]!, states[i]!);\n      }\n    },\n\n    addNet() {\n      return { ok: false, message: \"Static composition does not support dynamic nets\" };\n    },\n\n    removeNet() {\n      return { ok: false, message: \"Static composition does not support dynamic nets\" };\n    },\n\n    getActiveNets() {\n      return nets.map((net, i) => ({ name: net.name, net, state: states[i]! }));\n    },\n\n    getAllNets() {\n      return nets.map((net, i) => ({ name: net.name, net, state: states[i]!, active: true }));\n    },\n\n    formatStatus() {\n      return nets\n        .map((n, i) => `${n.name}: ${formatMarking(states[i]!.marking)}`)\n        .join(\"\\n\");\n    },\n\n    formatSystemPrompt() {\n      return formatPromptForNets(nets, states);\n    },\n\n    isDynamic: false,\n  };\n}\n\nfunction createRegistryManager(config: ComposeConfig): GateManager {\n  const registry = new Map<string, { net: SkillNet<string>; state: GateState<string> }>();\n  for (const [name, net] of Object.entries(config.registry)) {\n    registry.set(name, {\n      net,\n      state: createGateState(autoAdvance(net, { ...net.initialMarking })),\n    });\n  }\n\n  const activeNames = new Set<string>(config.active ?? Object.keys(config.registry));\n\n  const getActiveNets = () => [...activeNames].map((n) => registry.get(n)!.net);\n  const getActiveStates = () => [...activeNames].map((n) => registry.get(n)!.state);\n\n  return {\n    handleToolCall(event, ctx) {\n      return composedToolCall(getActiveNets, getActiveStates, event, ctx);\n    },\n\n    handleToolResult(event) {\n      for (const { net, state } of registry.values()) {\n        handleToolResultSingle(event, net, state);\n      }\n    },\n\n    addNet(name) {\n      if (!registry.has(name)) {\n        return { ok: false, message: `Unknown net '${name}'. Available: ${[...registry.keys()].join(\", \")}` };\n      }\n      if (activeNames.has(name)) {\n        return { ok: false, message: `'${name}' is already active` };\n      }\n      activeNames.add(name);\n      return { ok: true, message: `Activated '${name}'` };\n    },\n\n    removeNet(name) {\n      if (!activeNames.has(name)) {\n        return { ok: false, message: `'${name}' is not active. Active: ${[...activeNames].join(\", \")}` };\n      }\n      activeNames.delete(name);\n      return { ok: true, message: `Deactivated '${name}' (state preserved)` };\n    },\n\n    getActiveNets() {\n      return [...activeNames].map((name) => {\n        const entry = registry.get(name)!;\n        return { name, net: entry.net, state: entry.state };\n      });\n    },\n\n    getAllNets() {\n      return [...registry.entries()].map(([name, { net, state }]) => ({\n        name,\n        net,\n        state,\n        active: activeNames.has(name),\n      }));\n    },\n\n    formatStatus() {\n      return [...registry.entries()]\n        .map(([name, { state }]) => {\n          const status = activeNames.has(name) ? \"active\" : \"inactive\";\n          return `${name} (${status}): ${formatMarking(state.marking)}`;\n        })\n        .join(\"\\n\");\n    },\n\n    formatSystemPrompt() {\n      return formatPromptForNets(getActiveNets(), getActiveStates());\n    },\n\n    isDynamic: true,\n  };\n}\n\nfunction formatPromptForNets(nets: SkillNet<string>[], states: GateState<string>[]): string {\n  const sections = nets.map((net, i) => {\n    const enabled = getEnabledToolTransitions(net, states[i]!.marking);\n    const toolList = enabled.flatMap((t) => t.tools ?? []);\n    return `### ${net.name}\\nAvailable gated tools: ${toolList.join(\", \") || \"none\"}\\nFree tools: ${net.freeTools.join(\", \")}\\nState: ${formatMarking(states[i]!.marking)}`;\n  });\n  return `## Active Petri Nets (composed)\\n${sections.join(\"\\n\\n\")}`;\n}\n"],"mappings":"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","names":["import_engine","import_engine"]}