network-ai 3.3.2 → 3.3.4

package/README.md

@@ -4,7 +4,7 @@
 
 [![CI](https://github.com/jovanSAPFIONEER/Network-AI/actions/workflows/ci.yml/badge.svg)](https://github.com/jovanSAPFIONEER/Network-AI/actions/workflows/ci.yml)
 [![CodeQL](https://github.com/jovanSAPFIONEER/Network-AI/actions/workflows/codeql.yml/badge.svg)](https://github.com/jovanSAPFIONEER/Network-AI/actions/workflows/codeql.yml)
-[![Release](https://img.shields.io/badge/release-v3.3.2-blue.svg)](https://github.com/jovanSAPFIONEER/Network-AI/releases)
+[![Release](https://img.shields.io/badge/release-v3.3.4-blue.svg)](https://github.com/jovanSAPFIONEER/Network-AI/releases)
 [![npm](https://img.shields.io/npm/dw/network-ai.svg?label=npm%20downloads)](https://www.npmjs.com/package/network-ai)
 [![ClawHub](https://img.shields.io/badge/ClawHub-network--ai-orange.svg)](https://clawhub.ai/skills/network-ai)
 [![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)](https://nodejs.org)
@@ -19,12 +19,14 @@
 
 > **Legacy Users:** This skill works with **Clawdbot** and **Moltbot** (now OpenClaw). If you're searching for *Moltbot Security*, *Clawdbot Swarm*, or *Moltbot multi-agent* -- you're in the right place!
 
-Network-AI is a framework-agnostic multi-agent orchestrator and **behavioral control plane** that connects LLM agents across **12 frameworks** -- LangChain, AutoGen, CrewAI, OpenAI Assistants, LlamaIndex, Semantic Kernel, Haystack, DSPy, Agno, MCP, OpenClaw, and custom adapters. It provides shared blackboard coordination with atomic commits, built-in security (AES-256, HMAC tokens, rate limiting), content quality gates with hallucination detection, compliance enforcement, and agentic workflow patterns (parallel fan-out/fan-in, voting, chaining). Zero dependencies per adapter -- bring your own framework SDK and start building governed multi-agent systems in minutes.
+If network-ai saves you time, a ⭐ on GitHub helps others find it.
+
+Connect agents across **12 frameworks** through a shared blackboard with built-in security, compliance enforcement, and behavioral governance -- in a single `npm install`. No glue code, no lock-in.
 
 **Why Network-AI?**
-- **Framework-agnostic** -- Not locked to one LLM provider or agent SDK
-- **Governance layer** -- Permission gating, audit trails, budget ceilings, and compliance enforcement across all agents
-- **Shared state** -- Atomic blackboard with conflict resolution for safe parallel agent coordination (fan-out/fan-in)
+- **Framework-agnostic** -- LangChain, AutoGen, CrewAI, MCP, OpenAI Assistants, and 7 more in one orchestrator
+- **Governed coordination** -- FSM-controlled agent turns, permission gating, audit trails, budget ceilings
+- **Shared state** -- Atomic blackboard with conflict resolution for safe parallel agent coordination
 - **Production security** -- AES-256 encryption, HMAC audit logs, rate limiting, input sanitization
 - **Zero config** -- Works out of the box with `createSwarmOrchestrator()`
 
@@ -540,6 +542,190 @@ class MyAdapter extends BaseAdapter {
 
 See [references/adapter-system.md](references/adapter-system.md) for the full adapter architecture guide.
 
+## API Architecture & Performance
+
+**Your swarm is only as fast as the backend it calls into.**
+
+Network-AI is backend-agnostic — every agent in a swarm can call a cloud API, a different cloud API, or a local GPU model. That choice has a direct and significant impact on speed, parallelism, and reliability.
+
+### Why It Matters
+
+When you run a 5-agent swarm, Network-AI can dispatch all 5 calls simultaneously. Whether those calls actually execute in parallel depends entirely on what's behind each agent:
+
+| Backend | Parallelism | Typical 5-agent swarm | Notes |
+|---|---|---|---|
+| **Single cloud API key** (OpenAI, Anthropic, etc.) | Rate-limited | 40–70s sequential | RPM limits force sequential dispatch + retry waits |
+| **Multiple API keys / providers** | True parallel | 8–15s | Each agent hits a different key or provider |
+| **Local GPU** (Ollama, llama.cpp, vLLM) | True parallel | 5–20s depending on hardware | No RPM limit — all 5 agents fire simultaneously |
+| **Mixed** (some cloud, some local) | Partial | Varies | Local agents never block; cloud agents rate-paced |
+
+### The Single-Key Rate Limit Problem
+
+Cloud APIs enforce **Requests Per Minute (RPM)** limits per API key. When you run 5 agents sharing one key and hit the ceiling, the API silently returns empty responses — not a 429 error, just blank content. Network-AI's swarm demos handle this automatically with **sequential dispatch** (one agent at a time) and **adaptive header-based pacing** that reads the `x-ratelimit-reset-requests` header to wait exactly as long as needed before the next call.
+
+```
+Single key (gpt-5.2, 6 RPM limit):
+  Agent 1 ──call──▶ response (7s)
+                                wait 1s
+  Agent 2 ──call──▶ response (7s)
+                                wait 1s
+  ... (sequential)
+  Total: ~60s for 5 agents + coordinator
+```
+
+### Multiple Keys or Providers = True Parallel
+
+Register each reviewer agent against a different API key or provider and dispatch fires all 5 simultaneously:
+
+```typescript
+import { CustomAdapter, AdapterRegistry } from 'network-ai';
+
+// Each agent points to a different OpenAI key
+const registry = new AdapterRegistry();
+
+for (const reviewer of REVIEWERS) {
+  const adapter = new CustomAdapter();
+  const client  = new OpenAI({ apiKey: process.env[`OPENAI_KEY_${reviewer.id.toUpperCase()}`] });
+
+  adapter.registerHandler(reviewer.id, async (payload) => {
+    const resp = await client.chat.completions.create({ ... });
+    return { findings: extractContent(resp) };
+  });
+
+  registry.register(reviewer.id, adapter);
+}
+
+// Now all 5 dispatch in parallel via Promise.all
+// Total: ~8-12s instead of ~60s
+```
+
+### Local GPU = Zero Rate Limits
+
+Run Ollama or any OpenAI-compatible local server and drop it in as a backend. No RPM ceiling means every agent fires the moment the previous one starts — true parallel for free:
+
+```typescript
+// Point any agent at a local Ollama or vLLM server
+const localClient = new OpenAI({
+  apiKey    : 'not-needed',
+  baseURL   : 'http://localhost:11434/v1',
+});
+
+adapter.registerHandler('sec_review', async (payload) => {
+  const resp = await localClient.chat.completions.create({
+    model   : 'llama3.2',     // or mistral, deepseek-r1, codellama, etc.
+    messages: [...],
+  });
+  return { findings: extractContent(resp) };
+});
+```
+
+### Mixing Cloud and Local
+
+The adapter system makes it trivial to give some agents a cloud backend and others a local one:
+
+```typescript
+// Fast local model for lightweight reviewers
+registry.register('test_review',  localAdapter);
+registry.register('arch_review',  localAdapter);
+
+// Cloud model for high-stakes reviewers
+registry.register('sec_review',   cloudAdapter);  // GPT-4o / Claude
+```
+
+Network-AI's orchestrator, blackboard, and trust model stay identical regardless of what's behind each adapter. The only thing that changes is speed.
+
+### Summary
+
+| You have | What to expect |
+|---|---|
+| One cloud API key | Sequential dispatch, 40–70s per 5-agent swarm — fully handled automatically |
+| Multiple cloud keys | Near-parallel, 10–15s — use one key per adapter instance |
+| Local GPU (Ollama, vLLM) | True parallel, 5–20s depending on hardware |
+| Home GPU + cloud mix | Local agents never block — cloud agents rate-paced independently |
+
+The framework doesn't get in the way of any of these setups. Connect whatever backend you have and the orchestration layer handles the rest.
+
+### Cloud Provider Performance
+
+Not all cloud APIs perform the same. Model size, inference infrastructure, and tier all affect how fast each agent gets a response — and that directly multiplies across every agent in your swarm.
+
+| Provider / Model | Avg response (5-agent swarm) | RPM limit (free/tier-1) | Notes |
+|---|---|---|---|
+| **OpenAI gpt-5.2** | 6–10s per call | 3–6 RPM | Flagship model, high latency, strict RPM |
+| **OpenAI gpt-4o-mini** | 2–4s per call | 500 RPM | Fast, cheap, good for reviewer agents |
+| **OpenAI gpt-4o** | 4–7s per call | 60–500 RPM | Balanced quality/speed |
+| **Anthropic Claude 3.5 Haiku** | 2–3s per call | 50 RPM | Fastest Claude, great for parallel agents |
+| **Anthropic Claude 3.7 Sonnet** | 4–8s per call | 50 RPM | Stronger reasoning, higher latency |
+| **Google Gemini 2.0 Flash** | 1–3s per call | 15 RPM (free) | Very fast inference, low RPM on free tier |
+| **Groq (Llama 3.3 70B)** | 0.5–2s per call | 30 RPM | Fastest cloud inference available |
+| **Together AI / Fireworks** | 1–3s per call | Varies by plan | Good for parallel workloads, competitive RPM |
+
+**Key insight:** A 5-agent swarm using `gpt-4o-mini` at 500 RPM can fire all 5 agents truly in parallel and finish in ~4s total. The same swarm on `gpt-5.2` at 6 RPM must go sequential and takes 60s. **The model tier matters more than the orchestration framework.**
+
+#### Choosing a Model for Swarm Agents
+
+- **Speed over depth** (many agents, real-time feedback) → `gpt-4o-mini`, `gpt-5-mini`, `claude-3.5-haiku`, `gemini-2.0-flash`, `groq/llama-3.3-70b`
+- **Depth over speed** (fewer agents, high-stakes output) → `gpt-4o`, `claude-3.7-sonnet`, `gpt-5.2`
+- **Free / no-cost testing** → Groq free tier, Gemini free tier, or Ollama locally
+- **Production swarms with budget** → Multiple keys across providers, route different agents to different models
+
+All of these plug into Network-AI through the `CustomAdapter` by swapping the client's `baseURL` and `model` string — no other code changes needed.
+
+### `max_completion_tokens` — The Silent Truncation Trap
+
+One of the most common failure modes in agentic output tasks is **silent truncation**. When a model hits the `max_completion_tokens` ceiling it stops mid-output and returns whatever it has — no error, no warning. The API call succeeds with a 200 and `finish_reason: "length"` instead of `"stop"`.
+
+**This is especially dangerous for code-rewrite agents** where the output is a full file. A fixed `max_completion_tokens: 3000` cap will silently drop everything after line ~150 of a 200-line fix.
+
+```
+# What you set vs what you need
+
+max_completion_tokens: 3000  →  enough for a short blog post
+                             →  NOT enough for a 200-line code rewrite
+
+# Real numbers (gpt-5-mini, order-service.ts rewrite):
+  Blockers section:  ~120 tokens
+  Fixed code:        ~2,800 tokens  (213 lines with // FIX: comments)
+  Total needed:      ~3,000 tokens  ← hits the cap exactly, empty output
+  Fix: set to 16,000 → full rewrite delivered in one shot
+```
+
+**Lessons learned from building the code-review swarm:**
+
+| Issue | Root cause | Fix |
+|---|---|---|  
+| Fixed code output was empty | `max_completion_tokens: 3000` too low for a full rewrite | Raise to `16000`+ for any code-output agent |
+| `finish_reason: "length"` silently discards output | Model hits cap, returns partial response with no error | Always check `choices[0].finish_reason` and alert on `"length"` |
+| `gpt-5.2` slow + expensive for reviewer agents | Flagship model = high latency + $14/1M output tokens | Use `gpt-5-mini` ($2/1M, 128k output, same RPM) for reviewer/fixer agents |
+| Coordinator + fixer as two separate calls | Second call hits rate limit window, adds 60s wait | Merge into one combined call with a structured two-section response format |
+
+**Rule of thumb for `max_completion_tokens` by task:**
+
+| Task | Recommended cap |
+|---|---|
+| Short classification / sentiment | 200–500 |
+| Code review findings (one reviewer) | 400–800 |
+| Blocker summary (coordinator) | 500–1,000 |
+| Full file rewrite (≤300 lines) | 12,000–16,000 |
+| Full file rewrite (≤1,000 lines) | 32,000–64,000 |
+| Document / design revision | 16,000–32,000 |
+
+All GPT-5 variants (`gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-5.2`) support **128,000 max output tokens** — the ceiling is never the model, it's always the cap you set.
+
+#### Cloud GPU Instances (Self-Hosted on AWS / GCP / Azure)
+
+Running your own model on a cloud GPU VM (e.g. AWS `p3.2xlarge` / A100, GCP `a2-highgpu`, Azure `NC` series) sits between managed APIs and local hardware:
+
+| Setup | Parallelism | Speed vs managed API | RPM limit |
+|---|---|---|---|
+| A100 (80GB) + vLLM, Llama 3.3 70B | True parallel | **Faster** — 0.5–2s per call | None |
+| H100 + vLLM, Mixtral 8x7B | True parallel | **Faster** — 0.3–1s per call | None |
+| T4 / V100 + Ollama, Llama 3.2 8B | True parallel | Comparable | None |
+
+Since you own the endpoint, there are no rate limits — all 5 agents fire at the same moment. At inference speeds on an A100, a 5-agent swarm can complete in **3–8 seconds** for a 70B model, comparable to Groq and faster than any managed flagship model.
+
+The tradeoff is cost (GPU VMs are $1–$5/hr) and setup (vLLM install, model download). For high-volume production swarms or teams that want no external API dependency, it's the fastest architecture available. The connection is identical to local Ollama — just point `baseURL` at your VM's IP.
+
 ## Permission System
 
 The AuthGuardian evaluates requests using:

package/dist/run.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env ts-node
+export {};
+//# sourceMappingURL=run.d.ts.map

package/dist/run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../run.ts"],"names":[],"mappings":""}

package/dist/run.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env ts-node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * network-ai demo launcher
+ * Run: npx ts-node run.ts
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const child_process_1 = require("child_process");
+const readline = __importStar(require("readline"));
+// ─── Demo registry ────────────────────────────────────────────────────────────
+const DEMOS = [
+    { id: '01', file: 'examples/01-hello-swarm.ts', title: 'Hello Swarm', desc: '3-agent greeting pipeline' },
+    { id: '02', file: 'examples/02-fsm-pipeline.ts', title: 'FSM Pipeline', desc: 'Finite-state-machine task orchestration' },
+    { id: '03', file: 'examples/03-parallel-agents.ts', title: 'Parallel Agents', desc: 'Fan-out + merge pattern' },
+    { id: '04', file: 'examples/04-live-swarm.ts', title: 'AI Safety Swarm', desc: '9-agent live research swarm + executive summary' },
+    { id: '05', file: 'examples/05-code-review-swarm.ts', title: 'Code Review Swarm', desc: '5 specialist reviewers + coordinator verdict' },
+];
+// ─── Colours ──────────────────────────────────────────────────────────────────
+const c = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    cyan: '\x1b[36m',
+    yellow: '\x1b[33m',
+    green: '\x1b[32m',
+    red: '\x1b[31m',
+    white: '\x1b[97m',
+};
+function banner() {
+    console.clear();
+    console.log();
+    console.log(`  ${c.bold}${c.cyan}network-ai${c.reset}  —  demo launcher`);
+    console.log(`  ${c.dim}──────────────────────────────────────${c.reset}`);
+    console.log();
+}
+function printMenu(available) {
+    available.forEach((d, i) => {
+        const num = `${c.bold}${c.yellow}[${i + 1}]${c.reset}`;
+        const title = `${c.bold}${c.white}${d.title}${c.reset}`;
+        const desc = `${c.dim}${d.desc}${c.reset}`;
+        console.log(`  ${num}  ${title}`);
+        console.log(`       ${desc}`);
+        console.log();
+    });
+    console.log(`  ${c.dim}[q]  Quit${c.reset}`);
+    console.log();
+}
+function ask(prompt) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise(resolve => {
+        rl.question(prompt, answer => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+function runDemo(file) {
+    return new Promise((resolve, reject) => {
+        console.log();
+        console.log(`  ${c.dim}Launching: ${file}${c.reset}`);
+        console.log();
+        const proc = (0, child_process_1.spawn)('npx', ['ts-node', file], { stdio: 'inherit', shell: true, cwd: process.cwd() });
+        proc.on('exit', code => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(`Demo exited with code ${code}`));
+        });
+        proc.on('error', reject);
+    });
+}
+// ─── Main ─────────────────────────────────────────────────────────────────────
+async function main() {
+    const available = DEMOS.filter(d => (0, fs_1.existsSync)((0, path_1.join)(process.cwd(), d.file)));
+    while (true) {
+        banner();
+        printMenu(available);
+        const answer = await ask(`  ${c.bold}Choose a demo:${c.reset} `);
+        if (answer.toLowerCase() === 'q' || answer.toLowerCase() === 'quit') {
+            console.log(`\n  ${c.dim}Bye.${c.reset}\n`);
+            process.exit(0);
+        }
+        const idx = parseInt(answer) - 1;
+        if (isNaN(idx) || idx < 0 || idx >= available.length) {
+            console.log(`\n  ${c.red}Invalid choice — press Enter to try again.${c.reset}`);
+            await ask('');
+            continue;
+        }
+        const demo = available[idx];
+        try {
+            await runDemo(demo.file);
+        }
+        catch (err) {
+            console.log(`\n  ${c.red}${err.message}${c.reset}`);
+        }
+        console.log();
+        const again = await ask(`  ${c.dim}Back to menu? [Y/n]:${c.reset} `);
+        if (again.toLowerCase() === 'n') {
+            console.log(`\n  ${c.dim}Bye.${c.reset}\n`);
+            process.exit(0);
+        }
+    }
+}
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});
+//# sourceMappingURL=run.js.map

package/dist/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../run.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "network-ai",
-  "version": "3.3.2",
+  "version": "3.3.4",
   "description": "AI agent orchestration framework for TypeScript/Node.js - plug-and-play multi-agent coordination with 12 frameworks (LangChain, AutoGen, CrewAI, OpenAI Assistants, LlamaIndex, Semantic Kernel, Haystack, DSPy, Agno, MCP, OpenClaw). Built-in security, swarm intelligence, and agentic workflow patterns.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -70,6 +70,7 @@
   },
   "devDependencies": {
     "@types/node": "^25.2.3",
+    "openai": "^6.22.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
   },