everything-gemini 1.9.0 → 2.1.0

package/skills/triton-inference-server/SKILL.md

@@ -0,0 +1,221 @@
+---
+name: triton-inference-server
+description: Deploys, configures, and tunes NVIDIA Triton Inference Server for high-throughput, low-latency multi-model serving with dynamic batching and GPU acceleration.
+---
+
+# Triton Inference Server
+
+Provides production architecture and configuration patterns for serving deep learning and LLM models at enterprise scale with NVIDIA Triton Inference Server.
+
+---
+
+## 1. Architecture & Execution Model
+
+```
+ Client Application (gRPC / HTTP KServe v2)
+                  │
+                  ▼
+┌──────────────────────────────────────────────┐
+│       NVIDIA Triton Inference Server         │
+│                                              │
+│  ┌──────────────────┐  ┌──────────────────┐  │
+│  │ Dynamic Batching │  │ Model Concurrency│  │
+│  │ Scheduler        │  │ & GPU Instances  │  │
+│  └─────────┬────────┘  └────────┬─────────┘  │
+│            │                    │            │
+│            ▼                    ▼            │
+│  ┌────────────────────────────────────────┐  │
+│  │  Backend Engines                       │  │
+│  │  - TensorRT-LLM (High-speed generative)│  │
+│  │  - vLLM Engine (PagedAttention serving)│  │
+│  │  - ONNX Runtime (Embedding & classifier│  │
+│  │  - Python Backend (Custom preprocessing│  │
+│  └────────────────────────────────────────┘  │
+└──────────────────────┬───────────────────────┘
+                       │
+                       ▼
+          NVIDIA Tensor Core GPUs (H100/A100/L4)
+```
+
+---
+
+## 2. Model Repository Layout
+
+Triton requires a strict directory layout with versioned subdirectories and `config.pbtxt`:
+
+```text
+model_repository/
+├── embedding_model/
+│   ├── 1/
+│   │   └── model.onnx
+│   └── config.pbtxt
+└── llm_generator/
+    ├── 1/
+    │   └── model.py
+    └── config.pbtxt
+```
+
+---
+
+## 3. High-Throughput `config.pbtxt` Configuration
+
+Configures dynamic batching, GPU instance groups, and TensorRT acceleration:
+
+```protobuf
+name: "embedding_model"
+platform: "onnxruntime_onnx"
+max_batch_size: 128
+
+input [
+  {
+    name: "input_ids"
+    data_type: TYPE_INT64
+    dims: [ -1 ]
+  },
+  {
+    name: "attention_mask"
+    data_type: TYPE_INT64
+    dims: [ -1 ]
+  }
+]
+
+output [
+  {
+    name: "sentence_embedding"
+    data_type: TYPE_FP32
+    dims: [ 768 ]
+  }
+]
+
+# Maximize GPU utilization via dynamic queue batching
+dynamic_batching {
+  max_queue_delay_microseconds: 5000 # 5ms SLA window
+  preferred_batch_size: [ 16, 32, 64, 128 ]
+}
+
+# Run 2 concurrent model instances on GPU 0
+instance_group [
+  {
+    count: 2
+    kind: KIND_GPU
+    gpus: [ 0 ]
+  }
+]
+
+optimization {
+  execution_accelerators {
+    gpu_execution_accelerator : [ {
+      name : "tensorrt"
+      parameters { key: "precision_mode" value: "FP16" }
+      parameters { key: "max_workspace_size_bytes" value: "4294967296" }
+    }]
+  }
+}
+```
+
+---
+
+## 4. High-Performance gRPC Client (Python)
+
+Uses binary gRPC streaming with zero-copy serialization:
+
+```python
+import numpy as np
+import tritonclient.grpc as grpcclient
+from tritonclient.grpc import InferInput, InferRequestedOutput
+
+def query_triton_embeddings(
+    texts_token_ids: np.ndarray,
+    attention_masks: np.ndarray,
+    server_url: str = "localhost:8001"
+) -> np.ndarray:
+    """Queries Triton via low-latency gRPC channel."""
+    with grpcclient.InferenceServerClient(url=server_url) as client:
+        # Check server readiness
+        if not client.is_server_ready():
+            raise RuntimeError("Triton server is not healthy.")
+
+        inputs = [
+            InferInput("input_ids", texts_token_ids.shape, "INT64"),
+            InferInput("attention_mask", attention_masks.shape, "INT64")
+        ]
+        inputs[0].set_data_from_numpy(texts_token_ids)
+        inputs[1].set_data_from_numpy(attention_masks)
+
+        outputs = [InferRequestedOutput("sentence_embedding")]
+
+        response = client.infer(
+            model_name="embedding_model",
+            inputs=inputs,
+            outputs=outputs,
+            timeout=10.0
+        )
+
+        return response.as_numpy("sentence_embedding")
+```
+
+---
+
+## 5. Production Docker & Kubernetes Deployment
+
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: triton-inference-server
+  namespace: mlops
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: triton
+  template:
+    metadata:
+      labels:
+        app: triton
+    spec:
+      containers:
+        - name: triton
+          image: nvcr.io/nvidia/tritonserver:24.08-py3
+          args: ["tritonserver", "--model-repository=/models", "--strict-model-config=true"]
+          resources:
+            limits:
+              nvidia.com/gpu: 1
+              memory: 16Gi
+              cpu: "8"
+          ports:
+            - containerPort: 8000 # HTTP
+            - containerPort: 8001 # gRPC
+            - containerPort: 8002 # Metrics (Prometheus)
+          livenessProbe:
+            httpGet:
+              path: /v2/health/live
+              port: 8000
+            initialDelaySeconds: 30
+          readinessProbe:
+            httpGet:
+              path: /v2/health/ready
+              port: 8000
+            initialDelaySeconds: 15
+```
+
+---
+
+## 6. Performance Benchmarking & Profiling
+
+```bash
+# Verify health and loaded models via v2 API
+curl -s http://localhost:8000/v2/health/ready
+curl -s http://localhost:8000/v2/models/embedding_model/ready
+
+# Profile throughput and P99 latency with Perf Analyzer
+perf_analyzer -m embedding_model \
+  -u localhost:8001 -i gRPC \
+  --concurrency-range 1:16 \
+  --shape input_ids:128 \
+  --shape attention_mask:128 \
+  --percentile 99
+
+# Query Prometheus metrics
+curl -s http://localhost:8002/metrics | grep nv_inference_
+```

package/templates/full-power/mcp_config.json

@@ -57,6 +57,13 @@
     "puppeteer": {
       "command": "npx",
       "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
+    },
+    "brave-search": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
+      "env": {
+        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
+      }
     }
   }
 }

package/tests/cli.test.js

@@ -90,10 +90,10 @@ it('should benchmark ecosystem components and output valid JSON with --json', ()
   const res = runCli('benchmark --json');
   assert.strictEqual(res.status, 0);
   const data = JSON.parse(res.stdout);
-  assert.strictEqual(data.totalComponents, 75);
-  assert.strictEqual(data.progressiveSkillsCount, 56);
-  assert.strictEqual(data.scopedAgentsCount, 12);
-  assert.strictEqual(data.lifecycleHooksCount, 7);
+  assert.strictEqual(data.totalComponents, 84);
+  assert.strictEqual(data.progressiveSkillsCount, 63);
+  assert.strictEqual(data.scopedAgentsCount, 13);
+  assert.strictEqual(data.lifecycleHooksCount, 8);
   assert(data.totalRunbookTokens > 15000, 'Expected >15,000 runbook tokens');
   assert(data.estimatedTokensSavedPerTurn > 8000, 'Expected significant token savings');
 });
@@ -316,7 +316,7 @@ try {
     const dryRes = runCli(`bundle --output "${bundleTarget}" --dry-run`);
     assert.strictEqual(dryRes.status, 0);
     assert.match(dryRes.stdout, /DRY RUN MODE ACTIVATED/);
-    assert.match(dryRes.stdout, /Skills to bundle: 56/);
+    assert.match(dryRes.stdout, /Skills to bundle: 63/);
     assert.strictEqual(fs.existsSync(bundleTarget), false, 'Dry run should not create destination directory');
 
     // JSON Dry-run mode
@@ -324,7 +324,7 @@ try {
     assert.strictEqual(jsonRes.status, 0);
     const dryData = JSON.parse(jsonRes.stdout);
     assert.strictEqual(dryData.dryRun, true);
-    assert.strictEqual(dryData.manifest.components.totalCount, 75);
+    assert.strictEqual(dryData.manifest.components.totalCount, 84);
 
     // Live mode
     const liveRes = runCli(`bundle --output "${bundleTarget}"`);
@@ -423,15 +423,164 @@ try {
     assert.match(resRate.stdout, /Distributed Rate Limiting/);
   });
 
+  // Info for mlops-engineer and v2.0.0 skills
+  it('should display info for mlops-engineer subagent and v2.0.0 skills', () => {
+    const resMl = runCli('info mlops-engineer');
+    assert.strictEqual(resMl.status, 0);
+    assert.match(resMl.stdout, /MLOps Engineer/);
+
+    const resKeda = runCli('info keda-event-autoscaling');
+    assert.strictEqual(resKeda.status, 0);
+    assert.match(resKeda.stdout, /KEDA/);
+
+    const resChroma = runCli('info chromadb-vector-store');
+    assert.strictEqual(resChroma.status, 0);
+    assert.match(resChroma.stdout, /ChromaDB/);
+
+    const resOpa = runCli('info opa-gatekeeper-policy');
+    assert.strictEqual(resOpa.status, 0);
+    assert.match(resOpa.stdout, /Gatekeeper/);
+
+    const resTriton = runCli('info triton-inference-server');
+    assert.strictEqual(resTriton.status, 0);
+    assert.match(resTriton.stdout, /Triton/);
+  });
+
+  // Info for v2.1.0 Google Research Harness2 & Google Family skills
+  it('should display info for v2.1.0 Harness2, Google Flow, and Dataproc Spark skills', () => {
+    const resH2 = runCli('info harness2-recursive-optimization');
+    assert.strictEqual(resH2.status, 0);
+    assert.match(resH2.stdout, /Harness² Recursive Optimization/);
+
+    const resFlow = runCli('info google-flow-orchestrator');
+    assert.strictEqual(resFlow.status, 0);
+    assert.match(resFlow.stdout, /Google Flow Orchestrator/);
+
+    const resSpark = runCli('info dataproc-spark-analytics');
+    assert.strictEqual(resSpark.status, 0);
+    assert.match(resSpark.stdout, /Dataproc Spark Analytics/);
+  });
+
+  // Harness2 command and export format verification
+  it('should synthesize Google Research Harness2 workspace in dry-run, live, and JSON export modes', () => {
+    const h2Target = path.join(tempWorkspace, 'harness2-test-ws');
+
+    // Dry-run mode
+    const dryRes = runCli(`harness2 "${h2Target}" --dry-run`);
+    assert.strictEqual(dryRes.status, 0);
+    assert.match(dryRes.stdout, /DRY RUN MODE ACTIVATED/);
+    assert.match(dryRes.stdout, /Previewing Google Research Harness² Surfaces/);
+    assert.strictEqual(fs.existsSync(h2Target), false, 'Dry run should not create destination directory');
+
+    // JSON Dry-run mode
+    const jsonRes = runCli(`harness2 "${h2Target}" --dry-run --json`);
+    assert.strictEqual(jsonRes.status, 0);
+    const dryData = JSON.parse(jsonRes.stdout);
+    assert.strictEqual(dryData.dryRun, true);
+    assert.strictEqual(dryData.manifest.metrics.total_skills, 63);
+    assert.strictEqual(dryData.manifest.metrics.total_subagents, 13);
+    assert.strictEqual(dryData.manifest.metrics.total_hooks, 8);
+
+    // Live mode
+    const liveRes = runCli(`harness2 "${h2Target}"`);
+    assert.strictEqual(liveRes.status, 0);
+    assert.match(liveRes.stdout, /Google Research Harness² Workspace Synthesized Successfully/);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'harness.yaml')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'harness.json')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'prompts', 'GEMINI.md')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'memory', 'memory_spec.json')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'guidance', 'tool_selection_rules.md')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'subagents', 'planner.md')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'skills', 'harness2-recursive-optimization', 'SKILL.md')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'scripts', 'harness_probe.sh')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'scripts', 'harness_snapshot.sh')), true);
+    assert.strictEqual(fs.existsSync(path.join(h2Target, 'scripts', 'harness_rollback.sh')), true);
+
+    // Export with --format harness2
+    const h2ExportTarget = path.join(tempWorkspace, 'harness2-export-ws');
+    const exportRes = runCli(`export --format harness2 --output "${h2ExportTarget}"`);
+    assert.strictEqual(exportRes.status, 0);
+    assert.strictEqual(fs.existsSync(path.join(h2ExportTarget, 'harness.yaml')), true);
+  });
+
+  // Graph command verification
+  it('should render interaction graph in terminal, mermaid, and JSON formats', () => {
+    const resTerm = runCli('graph');
+    assert.strictEqual(resTerm.status, 0);
+    assert.match(resTerm.stdout, /Multi-Agent Topology & Dependency Graph/);
+    assert.match(resTerm.stdout, /MLOPS-ENGINEER/);
+
+    const resMermaid = runCli('graph --mermaid');
+    assert.strictEqual(resMermaid.status, 0);
+    assert.match(resMermaid.stdout, /graph TD/);
+    assert.match(resMermaid.stdout, /A_mlops_engineer/);
+
+    const resJson = runCli('graph --json');
+    assert.strictEqual(resJson.status, 0);
+    const data = JSON.parse(resJson.stdout);
+    assert.ok(data.totalNodes > 50, 'Graph should contain > 50 nodes');
+    assert.ok(data.totalEdges > 50, 'Graph should contain > 50 edges');
+    assert.ok(data.nodes.find(n => n.id === 'agent:mlops-engineer'));
+  });
+
   // Benchmark Components Verification
-  it('should report 75 components, 56 skills, and 12 subagents in benchmark --json', () => {
+  it('should report 84 components, 63 skills, and 13 subagents in benchmark --json', () => {
     const res = runCli('benchmark --json');
     assert.strictEqual(res.status, 0);
     const data = JSON.parse(res.stdout);
-    assert.strictEqual(data.totalComponents, 75, 'Total components should be 75');
-    assert.strictEqual(data.progressiveSkillsCount, 56, 'Progressive skills should be 56');
-    assert.strictEqual(data.scopedAgentsCount, 12, 'Scoped agents should be 12');
-    assert.strictEqual(data.lifecycleHooksCount, 7, 'Lifecycle hooks should be 7');
+    assert.strictEqual(data.totalComponents, 84, 'Total components should be 84');
+    assert.strictEqual(data.progressiveSkillsCount, 63, 'Progressive skills should be 63');
+    assert.strictEqual(data.scopedAgentsCount, 13, 'Scoped agents should be 13');
+    assert.strictEqual(data.lifecycleHooksCount, 8, 'Lifecycle hooks should be 8');
+  });
+
+  // Harness² Run & Ingest-Trace tests
+  it('should support harness2 run with local benchmark, hard spend limits, and dry-run/json modes', () => {
+    const testTasksDir = path.join(tempWorkspace, 'harness2-tasks');
+    // Dry-run mode
+    const dryRes = runCli(`harness2 run --dir "${testTasksDir}" --bench local --max-usd 15 --dry-run`);
+    assert.strictEqual(dryRes.status, 0);
+    assert.match(dryRes.stdout, /DRY RUN MODE ACTIVATED/);
+    assert.match(dryRes.stdout, /Spend Ceiling: \$15\.00 USD/);
+
+    // JSON export mode
+    const jsonRes = runCli(`harness2 run --dir "${testTasksDir}" --bench local --max-usd 25 --json`);
+    assert.strictEqual(jsonRes.status, 0);
+    const runData = JSON.parse(jsonRes.stdout);
+    assert.strictEqual(runData.engine, 'everything-gemini-harness2-runner');
+    assert.strictEqual(runData.benchmark, 'local');
+    assert.strictEqual(runData.spendGuardrail.maxSpendUsd, 25);
+    assert.strictEqual(runData.result.status, 'PASSED');
+  });
+
+  it('should support harness2 ingest-trace to generate automated regression probes', () => {
+    const sampleTracePath = path.join(tempWorkspace, 'production-failure.json');
+    fs.writeFileSync(sampleTracePath, JSON.stringify({
+      id: 'trace-spark-oom',
+      error: 'OutOfMemoryError: Container killed due to 16GB memory ceiling',
+      tool: 'dataproc-spark-analytics',
+      timestamp: '2026-10-19T18:00:00Z',
+      stack: 'Fatal: JVM worker heap exhausted at SparkExecutor.scala:42'
+    }, null, 2), 'utf8');
+
+    const traceOutDir = path.join(tempWorkspace, 'regression-tasks');
+    const ingestRes = runCli(`harness2 ingest-trace "${sampleTracePath}" --dir "${traceOutDir}"`);
+    assert.strictEqual(ingestRes.status, 0);
+    assert.match(ingestRes.stdout, /Production Trace Ingested into Harness² Regression Test/);
+
+    const generatedTask = path.join(traceOutDir, 'regression-trace-spark-oom.json');
+    assert.strictEqual(fs.existsSync(generatedTask), true);
+    const taskContent = JSON.parse(fs.readFileSync(generatedTask, 'utf8'));
+    assert.strictEqual(taskContent.id, 'regression-trace-spark-oom');
+    assert.strictEqual(taskContent.sourceTrace, 'production-failure.json');
+    assert.match(taskContent.errorCategory, /OutOfMemoryError/);
+  });
+
+  it('should display info for budget-guard lifecycle hook', () => {
+    const res = runCli('info budget-guard');
+    assert.strictEqual(res.status, 0);
+    assert.match(res.stdout, /budget-guard/);
+    assert.match(res.stdout, /PreToolUse/);
   });
 
 } finally {