adaptive-bitmask 1.0.0-rc.1

package/dist/ai/index.mjs

@@ -0,0 +1,173 @@
+import {
+  Arbiter,
+  BitmaskMessage,
+  Coordinator,
+  SchemaManager,
+  decode,
+  encode,
+  hasEmergency
+} from "../chunk-ZWEXRT33.mjs";
+
+// src/ai/session.ts
+var CoordinationSession = class {
+  schema;
+  coordinator;
+  arbiter;
+  _agentIds = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.schema = new SchemaManager({
+      emergencyPrefix: config.emergencyPrefix ?? "EMERGENCY_",
+      emergencyFeatures: config.emergencyFeatures
+    });
+    this.schema.registerAll(config.features);
+    this.coordinator = new Coordinator({
+      ...config.coordinatorConfig,
+      schemaVersion: this.schema.version
+    });
+    this.arbiter = new Arbiter(config.arbiterConfig);
+  }
+  /** Deterministic agent ID: FNV-1a hash of name → uint32. */
+  agentId(name) {
+    const cached = this._agentIds.get(name);
+    if (cached !== void 0) return cached;
+    let hash = 2166136261;
+    for (let i = 0; i < name.length; i++) {
+      hash ^= name.charCodeAt(i);
+      hash = Math.imul(hash, 16777619);
+    }
+    const id = hash >>> 0;
+    this._agentIds.set(name, id);
+    return id;
+  }
+  /** Start a new coordination round. Clears the coordinator buffer. */
+  startRound() {
+    this.coordinator.startRound();
+  }
+  /** Encode features + create message + receive in one call. */
+  report(agentName, features) {
+    const { mask, mapped, unmapped } = encode(
+      features,
+      this.schema.featureToBit
+    );
+    const msg = BitmaskMessage.now(
+      mask,
+      this.agentId(agentName),
+      this.schema.version
+    );
+    const accepted = this.coordinator.receive(msg);
+    return { accepted, mapped, unmapped };
+  }
+  /** Aggregate current buffer + score via arbiter. */
+  decide() {
+    const { aggregatedMask, confidence } = this.coordinator.aggregate();
+    const aggregatedFeatures = decode(aggregatedMask, this.schema.bitToFeatures);
+    const result = this.arbiter.score(aggregatedMask, confidence);
+    return {
+      decision: result.decision,
+      aggregatedFeatures,
+      confidence,
+      result
+    };
+  }
+};
+
+// src/ai/tools.ts
+import { tool } from "ai";
+import { z } from "zod";
+function createCoordinationTools(session) {
+  const reportObservation = tool({
+    description: "Report observed features to the coordination layer. Each feature string is encoded into the shared bitmask.",
+    parameters: z.object({
+      agentName: z.string().describe("Name identifying this agent"),
+      features: z.array(z.string()).describe("Feature names observed by this agent")
+    }),
+    execute: async ({ agentName, features }) => {
+      const result = session.report(agentName, features);
+      return {
+        accepted: result.accepted,
+        mapped: result.mapped,
+        unmapped: result.unmapped
+      };
+    }
+  });
+  const getConsensus = tool({
+    description: "Query the current aggregated consensus state across all agents.",
+    parameters: z.object({}),
+    execute: async () => {
+      const { aggregatedMask, confidence, uniqueAgents } = session.coordinator.aggregate();
+      const features = decode(aggregatedMask, session.schema.bitToFeatures);
+      const confidenceObj = {};
+      for (const [bit, conf] of confidence) {
+        confidenceObj[String(bit)] = conf;
+      }
+      return {
+        features,
+        confidence: confidenceObj,
+        agentCount: uniqueAgents
+      };
+    }
+  });
+  const requestDecision = tool({
+    description: "Trigger the arbiter to score the current aggregated state and return a decision.",
+    parameters: z.object({}),
+    execute: async () => {
+      const { decision, aggregatedFeatures, result } = session.decide();
+      return {
+        decision,
+        score: result.finalScore,
+        features: aggregatedFeatures,
+        hasEmergency: result.hasEmergency
+      };
+    }
+  });
+  return { reportObservation, getConsensus, requestDecision };
+}
+
+// src/ai/middleware.ts
+function createCoordinationMiddleware(session, options = {}) {
+  const { injectConsensus = false, autoEncodeToolCalls = false, agentName } = options;
+  if (autoEncodeToolCalls && !agentName) {
+    throw new Error("agentName is required when autoEncodeToolCalls is enabled");
+  }
+  const middleware = {};
+  if (injectConsensus) {
+    middleware.transformParams = async ({ params }) => {
+      const { aggregatedMask, confidence } = session.coordinator.aggregate();
+      const features = decode(aggregatedMask, session.schema.bitToFeatures);
+      const emergency = hasEmergency(aggregatedMask);
+      const confidenceEntries = Array.from(confidence.entries()).map(([bit, conf]) => `  bit ${bit}: ${(conf * 100).toFixed(0)}%`).join("\n");
+      const consensusText = [
+        "[Coordination Consensus]",
+        `Features: ${features.length > 0 ? features.join(", ") : "none"}`,
+        `Emergency: ${emergency}`,
+        confidenceEntries ? `Confidence:
+${confidenceEntries}` : ""
+      ].filter(Boolean).join("\n");
+      return {
+        ...params,
+        prompt: [
+          { role: "system", content: consensusText },
+          ...params.prompt
+        ]
+      };
+    };
+  }
+  if (autoEncodeToolCalls) {
+    middleware.wrapGenerate = async ({ doGenerate }) => {
+      const result = await doGenerate();
+      if (result.toolCalls && result.toolCalls.length > 0) {
+        const matchingFeatures = result.toolCalls.map((tc) => tc.toolName).filter((name) => session.schema.featureToBit.has(name));
+        if (matchingFeatures.length > 0) {
+          session.report(agentName, matchingFeatures);
+        }
+      }
+      return result;
+    };
+  }
+  return middleware;
+}
+export {
+  CoordinationSession,
+  createCoordinationMiddleware,
+  createCoordinationTools
+};