DEV Community: RESK

Build a Bitmask-Based LLM Security Firewall with reskSecure

RESK — Tue, 21 Jul 2026 07:01:12 +0000

Links:

GitHub: https://github.com/Resk-Security/reskSecure
PyPI: https://pypi.org/project/resksecure
Website: https://resk.fr

Most LLM safety approaches filter output text after generation. By then, the harmful token has already been sampled and inference resources wasted.

reskSecure flips this: it intercepts at the logits level, before token selection. Using a capability bitmask system, it makes dangerous tokens statistically impossible to generate.

Quick Start

pip install resksecure

Basic Usage

Create a policy file policy.yaml:

rules:
  - name: block-sql-injection
    severity: HARD
    patterns:
      - "DROP TABLE"
      - "UNION SELECT"
      - "OR 1=1"
  - name: discourage-pii
    severity: BIAS
    penalty: -5.0
    patterns:
      - "credit card"
      - "social security"

Integrate with your Python application:

from resksecure import Firewall

fw = Firewall.from_yaml("policy.yaml")
fw.start_watcher()  # hot-reload on file change

# In your inference loop:
def secure_generate(prompt: str, model, tokenizer):
    logits = model.forward(prompt)
    adjusted = fw.process_logits(logits, prompt)
    return sample_from(adjusted)

Key Architecture

reskSecure operates on a capability bitmask. Each rule assigns a bit position. When a prompt or tool call activates a bit, the corresponding token receives a penalty determined by the severity mode:

HARD mode: logit set to -infinity. The model can never pick that token.
BIAS mode: configurable negative penalty. The token can still be selected if context strongly warrants it.

Bitmasks compose with AND/OR logic, enabling complex policies from simple building blocks.

Hot-Reload in Production

The YAML policy watcher monitors your policy file. Change rules on the fly with zero downtime:

fw.start_watcher(interval=5.0)  # check every 5 seconds

Why Logits-Level?

Output filtering is reactive. Logits-level filtering is preventive:

Tool calls are blocked at the first token — the model can never start a disallowed function signature
No post-generation parsing overhead
Compatible with any sampling strategy

Check it out on GitHub or PyPI and let me know what security patterns you would block.

https://github.com/Resk-Security/reskSecure
https://pypi.org/project/resksecure
https://resk.fr

Secure Your Python LLM Pipeline with Resk-LLM: 11 Threat Detectors in One Middleware

RESK — Sat, 18 Jul 2026 07:01:07 +0000

Links

GitHub: https://github.com/Resk-Security/Resk-LLM
PyPI: https://pypi.org/project/resk-llm
Website: https://resk.fr

If you deploy an LLM in production you need layered security. System prompts help but they are not enough. Jailbreaks, prompt injections and exfiltration attempts can bypass instruction-based filters entirely.

Resk-LLM is an open source Python security toolkit that detects 11 categories of threats and integrates as FastAPI middleware. Lets see how easy it is to add.

Installation

pip install resk-llm

Quick Start

Add the security middleware to any FastAPI app:

from fastapi import FastAPI
from resk_llm import SecurityMiddleware

app = FastAPI()

# Enable all 11 detectors with default settings
app.add_middleware(SecurityMiddleware)

@app.post("/chat")
async def chat(prompt: str):
    # Your LLM call here
    # SecurityMiddleware handles detection automatically
    return {"response": await call_llm(prompt)}

What gets detected:

Prompt injection and jailbreak attempts
PII and sensitive data leaks
Code exfiltration and system prompt extraction
Token smuggling and adversarial suffix attacks
And 7 more categories covering the OWASP LLM Top 10

Threat Response

Each detection can be configured to:

Block: Reject the request entirely
Flag: Log the attempt and let it pass
Replace: Sanitise the offending content

resk-logits Integration

For token-level blocking pair Resk-LLM with resk-logits. Dangerous tokens are shadow-banned at the logits layer via GPU accelerated Aho-Corasick matching. The model never even generates the first token of a forbidden phrase.

Why Use It

Single pip install covers your entire threat surface
Production-ready FastAPI middleware drops in with one line
Open source under MIT licensed
Active development and community contributions on GitHub

get started today: pip install resk-llm

https://github.com/Resk-Security/Resk-LLM
https://pypi.org/project/resk-llm
https://resk.fr

Secure Your TypeScript LLM Pipeline with resk-llm-ts: 11 Threat Detectors in One npm Package

RESK — Fri, 17 Jul 2026 07:01:22 +0000

Links:

npm: https://www.npmjs.com/package/resk-llm-ts
GitHub: https://github.com/Resk-Security/resk-llm-ts
Web: https://resk.fr

If you expose an LLM endpoint in your TypeScript backend, every user request is a potential attack vector. Prompt injections, jailbreak attempts, PII leaks, and exfiltration of system prompts all happen through the same text input you pass to your model.

The Problem

Instruction-based filters like "ignore previous instructions" do not work. Models follow user instructions by design. You need a structural defense at the middleware layer — before the request reaches your AI provider.

Enter resk-llm-ts

resk-llm-ts is an open source TypeScript library that sits between your API route and your LLM call. It inspects every input with 11 independent threat detectors and blocks malicious content before your model ever sees it.

Here is a minimal Express example:

import express from 'express';
import { createInjectionDetector } from 'resk-llm-ts';

const app = express();
app.use(express.json());

const injectionCheck = createInjectionDetector();

app.post('/chat', async (req, res) => {
  const result = await injectionCheck.analyze(req.body.message);

  if (result.flagged) {
    return res.status(400).json({
      error: 'Content blocked',
      reason: result.categories.join(', ')
    });
  }

  // Safe to call your LLM
  const reply = await callOpenAI(req.body.message);
  res.json({ reply });
});

The 11 Detectors

Each detector is an independent module you can enable or disable:

Injection Detector — catches prompt injection and jailbreak patterns
PII Scanner — finds emails, SSNs, credit cards, phone numbers
Exfiltration Guard — detects system prompt extraction attempts
Code Detector — spots hidden code execution or SQL injection in prompts
URL Safety — validates links for phishing and malware
Toxicity Filter — flags abusive, hateful, or harmful content
Sensitive Topic Guard — blocks conversations on disallowed subjects
Language Enforcer — restricts model output to permitted languages
Relevancy Checker — ensures user input stays on topic for your use case
Redact Engine — auto-redacts secrets from logs and traces
Pattern Blocker — custom regex rules for your specific blocking needs

Middleware Support

resk-llm-ts plugs into your framework of choice:

// Express middleware
import { protectLLMEndpoint } from 'resk-llm-ts/express';
app.use('/api/chat', protectLLMEndpoint());

// Hono middleware
import { llmSecurity } from 'resk-llm-ts/hono';
app.use('/api/chat', llmSecurity());

// OpenAI-compatible wrapper
import { SecurityWrapper } from 'resk-llm-ts';
const secureOpenAI = new SecurityWrapper(openai);
const response = await secureOpenAI.chat.completions.create({ ... });

Installation

npm install resk-llm-ts

Requires Node.js 18+. No external dependencies beyond TypeScript 5.x.

Why This Matters

70% of organizations lack AI governance according to PwC. Most rely on brittle prompt engineering as their only defense. resk-llm-ts gives you structural security at the gateway — before a single token reaches your LLM provider.

The library is GPL-3.0 open source, built and maintained by RESK Security.

Check it out, star the repo, and let me know what you think in the comments. What threat patterns do you see most in your AI applications?

👉 npm install resk-llm-ts
👉 https://github.com/Resk-Security/resk-llm-ts
👉 https://resk.fr

Secure Your Python LLM Pipeline with Resk-LLM — 11 Threat Detectors in One pip Install

RESK — Thu, 16 Jul 2026 07:02:17 +0000

Links

GitHub: github.com/Resk-Security/Resk-LLM
PyPI: pypi.org/project/resk-llm
Web: resk.fr

Prompt injection and jailbreak attacks are the most common LLM security threats today. Most defenses are either too slow for real-time use or locked behind proprietary APIs.

Resk-LLM is an open source Python toolkit that brings 11 threat detectors into a single FastAPI middleware. Install it, decorate your endpoint, and get instant protection against prompt injection, jailbreak, PII leakage, code injection, exfiltration, and more.

Installation

pip install resk-llm

FastAPI Middleware Example

from fastapi import FastAPI
from resk_llm import RESKSecurityMiddleware

app = FastAPI()

# Attach threat detection to your LLM route
app.add_middleware(
    RESKSecurityMiddleware,
    detectors=["injection", "jailbreak", "pii", "exfiltration"],
    mode="block"  # or "log" for monitoring
)

@app.post("/chat")
async def chat(message: dict):
    # If we reach here, input passed all detectors
    response = await call_your_llm(message["content"])
    return {"response": response}

Available Detectors

Detector	What It Catches
Prompt Injection	DAN, ignore-prior-instructions, role-play escapes
Jailbreak	Hypothetical traps, obfuscated instructions
PII Leakage	Emails, phone numbers, SSNs, credit cards
Exfiltration	Prompt stealing, data dumping
Toxic Content	Hate speech, harassment, profanity
Code Injection	SQL, shell, Python eval attempts
URL Phishing	Malicious URL patterns
And 4 more	Hidden content, base64 encoding, etc.

Why Dual-Layer Defense?

Resk-LLM works on the input side, catching threats before they reach the model. For even stronger protection, pair it with resk-logits — a GPU-accelerated logits processor that blocks dangerous tokens at generation time. Combined, you get input filtering AND output sanitation in one pipeline.

Production Ready

MIT licensed, open source
Python 3.13+ and PyTorch 2.0+
Zero external API dependencies
Configurable per-route policies
Log mode for evaluation, block mode for production

pip install resk-llm

Try it on your next project. Open an issue if a detector misses something — this is community-driven security, and feedback makes it better.

Protect Your Node.js LLM from Prompt Injection with resk-llm-ts

RESK — Wed, 15 Jul 2026 07:01:01 +0000

Links

GitHub: github.com/Resk-Security/resk-llm-ts
NPM: npmjs.com/package/resk-llm-ts
Web: resk.fr

If you serve LLM endpoints in Node.js, you face the same security risks as Python deployments — prompt injection, jailbreak attempts, PII leakage, and tool abuse. The difference? Most AI security toolkits are Python-only.

resk-llm-ts changes that. It is a TypeScript-first LLM security toolkit with 11 threat detectors that plugs into Express, Hono, or any OpenAI-compatible client.

Quick Start

npm install resk-llm-ts

Express Middleware Example

import express from 'express';
import { createMiddleware } from 'resk-llm-ts';

const app = express();
app.use(express.json());

// Attach threat detection to your LLM route
app.post('/api/chat', 
  createMiddleware({
    detectors: ['injection', 'jailbreak', 'pii'],
    mode: 'block' // or 'log'
  }),
  async (req, res) => {
    // If we reach here, the input passed all detectors
    const reply = await callYourLLM(req.body.message);
    res.json({ reply });
  }
);

app.listen(3000);

What Gets Detected

Detector	What It Catches
Prompt Injection	DAN, ignore-prior-instructions patterns
Jailbreak	Role-play escapes, hypothetical traps
PII Leakage	Phone numbers, emails, SSNs
Exfiltration	Prompt-stealing, data-dumping attempts
Toxic Content	Hate speech, harassment
And 6 more...	Code injection, URL phishing, etc.

Why TypeScript Matters

The Node.js ecosystem powers AI agents, middleware, and API gateways. If your security scanner only exists in Python, you ship blind on the JS side. resk-llm-ts closes that gap with first-class type definitions, zero-dependency core, and framework-native integration.

Next Steps

npm install resk-llm-ts
# Or check the docs on resk.fr

Try it on your next project and open an issue if a detector misses something — this is community-driven security.

Trace Every AI Agent Action with ReskPoints — Open Source Agent Logger

RESK — Tue, 14 Jul 2026 07:01:01 +0000

Links:

PyPI: https://pypi.org/project/reskpoints
GitHub: https://github.com/Resk-Security/ReskPoints
RESK Security: https://resk.fr

AI agents are getting more autonomous every week. But with autonomy comes a visibility problem: what did your agent actually do?

ReskPoints is an open source Python library that traces every agent action with sampling, masking, and multi-export. It gives you observability without the overhead.

Quick Start

pip install reskpoints

Then decorate your agent functions:

from reskpoints import trace, configure

configure(exporters=["console", "datadog"])

@trace(sample_rate=0.5)
def search_knowledge_base(query: str):
    # Your agent logic here
    return results

Key Features

Adaptive Sampling — control verbosity per function so hot paths dont flood your logs
Built-in Masking — redact API keys, PII, or any pattern before data leaves your process
Multi-Export — Console, Datadog, Prometheus, OpenTelemetry, file, and webhooks all supported from one config
YAML Config — no code changes to switch logging backends

# config.yaml
exporters:
  - console
  - datadog:
      api_key: ${DD_API_KEY}
      service: my-agent
sampling:
  default_rate: 0.1
  overrides:
    search_knowledge_base: 1.0
masking:
  patterns:
    - "sk-[A-Za-z0-9]+"
    - "\\b\\d{16}\\b"

Why Agent Logging Matters

When an autonomous agent hallucinates a tool call or leaks data through a prompt injection, you need the trace to understand what happened. ReskPoints gives you that trace with minimal overhead.

Install it today and start seeing what your agents actually do.

pip install reskpoints

Check the GitHub repo for full docs and examples.

Build a Bitmask-Based LLM Security Firewall with reskSecure

RESK — Mon, 13 Jul 2026 07:02:14 +0000

Test retry after waiting.

Block Unsafe Tokens Before Generation with resk-logits — GPU-Accelerated Aho-Corasick for LLM Safety

RESK — Sun, 12 Jul 2026 07:01:23 +0000

Links

GitHub: https://github.com/Resk-Security/resk-logits
PyPI: https://pypi.org/project/resklogits
Site: https://resk.fr

Most LLM safety filters are reactive: they scan generated text for bad patterns after the model already output them. For production systems, thats too late. The token is already sampled, logged, and potentially served to a user.

resk-logits takes a different approach: it intercepts at the logits level, before the model samples a token. Using a GPU-accelerated Aho-Corasick automaton, it matches 10000+ unsafe patterns against potential token completions in real time and applies a configurable penalty to matching logits.

How it works

import torch
from resklogits import LogitsProcessor

processor = LogitsProcessor()

# Load your patterns
processor.add_patterns([
    "ignore previous instructions",
    "role: system",
    "<|im_end|>",
    # ... more patterns
])

# In your generation loop
class ReskLogitsWarper:
    def __call__(self, input_ids, scores):
        return processor(scores, mode="hard")

# Use with HuggingFace generate
outputs = model.generate(
    input_ids,
    logits_processor=[ReskLogitsWarper()]
)

Key features

GPU-accelerated: runs 10000+ patterns in under 1ms on RTX 4090
Two severity modes: hard sets matching logits to -inf, bias applies a configurable penalty
Dynamic reloading: add or remove patterns at runtime
PyTorch native: works with any HuggingFace model
C++/CUDA backend: minimal overhead in the generation loop

Getting started

pip install resklogits

resk-logits is Apache 2.0 licensed and open source. Check the GitHub repo for detailed docs, pattern management, and integration examples.

RESK Security builds open-source AI security tools for production LLM deployments. Learn more at resk.fr.

ReskPoints: AI Agent Logging with Sampling, Masking, and Multi-Export

RESK — Sat, 11 Jul 2026 07:01:00 +0000

ReskPoints makes every agent action observable. Console, Datadog, Prometheus, OpenTelemetry — one install, all exporters.

Links:

GitHub: https://github.com/Resk-Security/ReskPoints
PyPI: https://pypi.org/project/reskpoints
Website: https://resk.fr

The Problem

A typical AI agent orchestrator makes dozens of tool calls per user request. Each call has request parameters a response latency and a success or failure state. When something goes wrong you need to replay what the agent was thinking and doing.

Standard Python logging gives you raw text. Datadog APM gives you traces but not the agent intent layer. You need a purpose-built logger that captures the agent loop not just the HTTP calls.

The Solution

ReskPoints is a Python library that hooks into your agent loop and records every action with context. Here is the core API:

from reskpoints import AgentLogger

logger = AgentLogger(
    service="my-agent",
    sampling_rate=0.1,   # keep 10 percent of actions
    exporters=[
        "console",
        "datadog",
        "prometheus"
    ],
    masks=[
        "api_key",
        "user.email"
    ]
)

# Inside your agent loop
logger.log_action(
    action="tool_call",
    tool="search_docs",
    input={"query": user_input},
    output=result,
    duration_ms=340,
    token_count=1200
)

Key Features

Sampling — keep 10 percent of actions and 100 percent of errors. Saves costs on high-volume agents.
Masking — regex-based field protection. Sensitive data never leaves the agent process.
Multi-export — write to Console, Datadog, Prometheus, OpenTelemetry, webhooks, or local files. Swap without changing agent code.
Zero-overhead when idle — no background threads or polling loops.

The library works with Python 3.13+ and has zero required dependencies beyond the exporters you use.

Get Started

pip install reskpoints

Then add one AgentLogger instance to your agent loop and wire your exporters. Full docs on GitHub.

https://github.com/Resk-Security/ReskPoints

What logging setup do you use for your AI agents?

resk-llm-ts: Open Source TypeScript Security Toolkit for LLM Applications

RESK — Fri, 10 Jul 2026 07:01:46 +0000

Links:

GitHub: https://github.com/Resk-Security/resk-llm-ts
NPM: https://npmjs.com/package/resk-llm-ts
Website: https://resk.fr

If you are building LLM-powered applications in Node.js or TypeScript, you have probably thought about security. Prompt injection, jailbreak attempts, PII leaks, and data exfiltration are real threats that traditional input sanitization does not catch at the LLM layer.

Most security toolkits are Python-only. TypeScript developers deserve the same protection.

resk-llm-ts is an open source TypeScript security toolkit with 11 threat detectors. It works as Express middleware, Hono middleware, or as an OpenAI-compatible wrapper.

Quick Start

npm install resk-llm-ts

Basic Usage

import { LLMSecurity } from "resk-llm-ts";

const security = new LLMSecurity({
  enabledDetectors: ["injection", "jailbreak", "pii", "exfiltration"],
  mode: "block", // or "log"
});

// Use as middleware with Express
app.post("/api/chat", security.middleware(), async (req, res) => {
  // req.body has been scanned - threats are blocked or logged
  const response = await openai.chat.completions.create({
    model: "gpt-4",
    messages: req.body.messages,
  });
  res.json(response);
});

Or use the OpenAI-compatible wrapper:

import { SecureOpenAI } from "resk-llm-ts";

const client = new SecureOpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  detectors: ["injection", "jailbreak"],
});

const response = await client.chat.completions.create({
  model: "gpt-4",
  messages: [{ role: "user", content: userInput }],
});

All 11 Detectors

Detector	Purpose
injection	Prompt injection detection
jailbreak	Jailbreak pattern recognition
pii	PII and sensitive data scanning
exfiltration	Data exfiltration prevention
code-injection	Code injection detection
toxic-content	Toxic content filtering
political	Political content detection
adversarial	Adversarial suffix detection
encoded-payload	Base64/hex encoded threat detection
role-play	Role-play manipulation detection
system-prompt	System prompt leak prevention

Why resk-llm-ts?

TypeScript-first: Full type definitions, works with any Node.js framework
Middleware-ready: Drop into Express, Hono, Fastify, or any connect-compatible framework
OpenAI-compatible wrapper: Replace your OpenAI client with zero API changes
Dual mode: Block threats or log them for analysis
GPL-3.0 open source: Free to use, modify, and contribute to

Security for LLM applications should not be an afterthought. Add it as middleware and ship with confidence.

Check it out on GitHub: https://github.com/Resk-Security/resk-llm-ts

Install: https://npmjs.com/package/resk-llm-ts

Learn more: https://resk.fr

AI Agent Observability: Track Every Tool Call with ReskPoints

RESK — Thu, 09 Jul 2026 07:01:45 +0000

Links

PyPI: https://pypi.org/project/reskpoints
GitHub: https://github.com/Resk-Security/ReskPoints
Organisation: https://resk.fr

AI agents are hard to debug. When your agent makes a tool call, calls an API, or reads a file, where does that show up? Most teams rely on print statements or build custom logging for each integration — and that does not scale.

ReskPoints changes that. It is an open-source AI Agent Logger that gives you structured, exportable traces of every action your agent takes.

Quick Start

pip install reskpoints

Create a logger:

from reskpoints import AgentLogger

logger = AgentLogger(
    service_name="my-agent",
    sampling_rate=1.0,  # log every action
    export="console"
)

# Log any action your agent performs
logger.log_action(
    action="tool_call",
    tool="web_search",
    parameters={"query": "latest AI news"},
    result="3 results returned",
    duration_ms=450
)

Multi-Export in One Line

Switch to Prometheus or Datadog without changing your code:

from reskpoints import AgentLogger

logger = AgentLogger(
    service_name="production-agent",
    export="prometheus",
    prometheus_port=8000
)

Or send to multiple backends:

logger = AgentLogger(
    service_name="multi-export-agent",
    export="datadog+console+opentelemetry"
)

Smart Sampling

ReskPoints supports configurable sampling so you control the volume — log every Nth call, or every call above a configurable threshold. Masking redacts sensitive fields automatically before they hit your observability pipeline.

Why This Matters

70 percent of organisations lack AI governance according to PwC. Visibility into agent behaviour is the first step. ReskPoints gives you that visibility in five minutes.

pip install reskpoints

Check it out on GitHub: https://github.com/Resk-Security/ReskPoints — contributions and feedback welcome.

LLM Inference Firewall: Blocking Unsafe Tokens Before Generation with Bitmasks

RESK — Wed, 08 Jul 2026 12:34:13 +0000

LLM Inference Firewall at the Logits Level

Most LLM safety approaches filter outputs after generation. resk-secure takes a different approach: it blocks forbidden tokens at the logits level before they reach the model.

The Core Idea

Compile safety rules into a GPU-compatible bitmask and apply it to the logits tensor before sampling. Unsafe tokens get zeroed out before they ever appear in the context window.

import torch
from resk_secure import BitmaskFirewall

firewall = BitmaskFirewall()
firewall.block_tokens(["jailbreak", "bypass"])

with torch.no_grad():
    logits = model(input_ids)
    masked_logits = firewall.apply_mask(logits)
    probs = torch.softmax(masked_logits, dim=-1)
    next_token = torch.multinomial(probs, 1)

Architecture Diagram

The pipeline: input tokens go through the model, logits are masked with the safety bitmask, and only safe tokens proceed to sampling.

Why Bitmasks?

O(1) per-token overhead instead of linear scan of generated output
Catches blocklist patterns even across token boundaries with regex
Works with streaming inference
CPU and CUDA backends
Default blocklist for common jailbreak patterns included