state-integrity-protocol 0.1.0__tar.gz

state_integrity_protocol-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2026 sijan324 (sijangautamx@gmail.com)
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  DEVELOPER WARNING FOR COMMERCIAL USERS: If you modify this Program or 
+run a derivative version of it on a network server to provide cloud 
+services, you MUST legally open-source your entire cloud platform code 
+to the public under the same AGPL-3.0 terms. If you do not wish to share 
+your server code, you must purchase a private proprietary corporate 
+license from the original copyright holder (sijan324).
+
+[The remaining standard full text of the GNU AGPL v3 license applies 
+here to govern this repository and its mathematical test suites.]

state_integrity_protocol-0.1.0/PKG-INFO

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: state-integrity-protocol
+Version: 0.1.0
+Summary: Minimal Python SDK for semantic drift detection and state integrity tracking.
+License: AGPL-3.0
+Keywords: ai,agents,drift-detection,semantic-anchor,llm
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: sentence-transformers>=2.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: scikit-learn>=1.2.0; extra == "dev"
+Dynamic: license-file
+
+# 🧬 State Integrity Protocol (SIP)
+
+> A lightweight runtime layer for detecting and preventing semantic drift in LLM outputs.
+
+SIP helps AI systems stay **faithful to user intent** across generation, transformation, and multi-agent workflows.
+
+---
+
+## ⚠️ Problem
+
+LLMs can fail silently by:
+
+- drifting from original intent
+- adding unwanted assumptions
+- changing numbers, constraints, or meaning
+- hallucinating details that were never requested
+
+This makes AI outputs less reliable in production systems.
+
+---
+
+## 🧠 Solution
+
+SIP introduces a runtime integrity loop:
+
+**Intent → Anchor → Output → Observe → Drift Score → Decision**
+
+Every generated output is checked against the original anchored intent before it is accepted.
+
+---
+
+## ⚙️ Core Concept
+
+SIP operates in three stages:
+
+### 1) Anchor (Intent Definition)
+
+Define the original intent:
+
+```python
+sip.anchor("Refund user $50 within 7 days")
+```
+
+### 2) Observe (Output Evaluation)
+
+Compare generated output against the anchor:
+
+```python
+result = sip.observe("Refund user $500 immediately")
+```
+
+### 3) Decision Layer
+
+Use alignment and drift signals to decide accept/repair/reject:
+
+```python
+print(result.is_aligned)
+print(result.drift)
+```
+
+---
+
+## 🔁 Example
+
+```python
+from sip import StateIntegrityProtocol
+
+sip = StateIntegrityProtocol()
+
+sip.anchor("Delete user account safely")
+result = sip.observe("Create new user account")
+
+print(result.is_aligned)  # False
+print(result.drift)       # e.g., 0.61
+```
+
+`ObservationResult` exposes both `drift` and `last_drift`; both reference the same latest drift score.
+
+---
+
+## 🧱 Architecture
+
+SIP is designed as middleware for AI systems:
+
+```text
+User / Agent
+    ↓
+LLM (generation)
+    ↓
+SIP Middleware
+    ├── Drift detection
+    ├── Intent alignment check
+    ├── Constraint validation
+    ↓
+Decision: Accept / Repair / Reject
+```
+
+---
+
+## 🔐 What SIP Detects
+
+- semantic drift
+- numerical manipulation
+- instruction leakage
+- constraint violations
+- intent mismatch
+- prompt injection attempts
+
+---
+
+## 🚀 Why This Matters
+
+SIP makes AI systems:
+
+- more reliable
+- more predictable
+- safer for production use
+- easier to audit
+
+---
+
+## 🧩 Use Cases
+
+- AI agents
+- LLM pipelines
+- autonomous workflows
+- enterprise AI systems
+- chatbots with strict behavior controls
+
+---
+
+## 📦 Installation
+
+```bash
+pip install -e .
+```
+
+For development and tests:
+
+```bash
+python -m pip install -e '.[dev]'
+```
+
+---
+
+## 🧠 Core API
+
+- `anchor(prompt: str)` — define the initial intent state
+- `observe(output: str)` — evaluate drift from the anchored intent
+- `is_aligned: bool` — alignment signal
+- `drift: float` — latest drift score (alias)
+- `last_drift: float` — latest drift score
+- `history: list` — transition history
+- `SIPMiddlewarePipeline` — optional anchor → checks → verify/sign → repair loop orchestration
+
+---
+
+## 🛡️ Middleware + Verification Flow
+
+The optional pipeline can run:
+
+1. drift check against the anchor
+2. intent-alignment check
+3. constraint-violation check
+4. `verify_and_sign()` decision
+5. accept/repair/reject routing
+
+```python
+from sip import SIPMiddlewarePipeline
+
+pipeline = SIPMiddlewarePipeline(
+    drift_threshold=0.15,
+    intent_alignment_threshold=0.3,
+    constraints=["do not mention internal token"],
+    max_retries=2,
+)
+
+pipeline.anchor("Summarize refund policy in 3 bullet points")
+result = pipeline.run(
+    "Refund policy summary in 3 bullet points without internal token."
+)
+
+print(result.status)                 # accepted | repair_required | rejected
+print(result.decision.signature)     # deterministic decision signature
+print(result.decision.failure_codes) # machine-readable failure causes
+print(result.repair_instructions)    # guidance when not accepted
+```
+
+### Policy Knobs
+
+- `drift_threshold`: maximum allowed semantic drift
+- `intent_alignment_threshold`: minimum token-overlap score
+- `constraints`: blocked words/phrases
+- `max_retries`: max repair attempts before rejection
+- `signer`: optional custom signing function for `verify_and_sign()`
+
+---
+
+## 🧪 Testing
+
+```bash
+python -m pytest tests/ -v
+```
+
+---
+
+## 🛡️ Philosophy
+
+> “AI should not just generate outputs — it should stay faithful to intent.”
+
+SIP enforces that principle at runtime.
+
+---
+
+## Licensing & Commercial Use
+
+- Core SDK (SIP) is licensed under AGPL-3.0.
+- **AI Sentinel** (the full monitoring system) is a separate commercial product and is **not open source**.
+- Companies can use SIP under AGPL terms.
+- For commercial hosted service, white-label, or custom enterprise versions, please contact us.

state_integrity_protocol-0.1.0/README.md

@@ -0,0 +1,220 @@
+# 🧬 State Integrity Protocol (SIP)
+
+> A lightweight runtime layer for detecting and preventing semantic drift in LLM outputs.
+
+SIP helps AI systems stay **faithful to user intent** across generation, transformation, and multi-agent workflows.
+
+---
+
+## ⚠️ Problem
+
+LLMs can fail silently by:
+
+- drifting from original intent
+- adding unwanted assumptions
+- changing numbers, constraints, or meaning
+- hallucinating details that were never requested
+
+This makes AI outputs less reliable in production systems.
+
+---
+
+## 🧠 Solution
+
+SIP introduces a runtime integrity loop:
+
+**Intent → Anchor → Output → Observe → Drift Score → Decision**
+
+Every generated output is checked against the original anchored intent before it is accepted.
+
+---
+
+## ⚙️ Core Concept
+
+SIP operates in three stages:
+
+### 1) Anchor (Intent Definition)
+
+Define the original intent:
+
+```python
+sip.anchor("Refund user $50 within 7 days")
+```
+
+### 2) Observe (Output Evaluation)
+
+Compare generated output against the anchor:
+
+```python
+result = sip.observe("Refund user $500 immediately")
+```
+
+### 3) Decision Layer
+
+Use alignment and drift signals to decide accept/repair/reject:
+
+```python
+print(result.is_aligned)
+print(result.drift)
+```
+
+---
+
+## 🔁 Example
+
+```python
+from sip import StateIntegrityProtocol
+
+sip = StateIntegrityProtocol()
+
+sip.anchor("Delete user account safely")
+result = sip.observe("Create new user account")
+
+print(result.is_aligned)  # False
+print(result.drift)       # e.g., 0.61
+```
+
+`ObservationResult` exposes both `drift` and `last_drift`; both reference the same latest drift score.
+
+---
+
+## 🧱 Architecture
+
+SIP is designed as middleware for AI systems:
+
+```text
+User / Agent
+    ↓
+LLM (generation)
+    ↓
+SIP Middleware
+    ├── Drift detection
+    ├── Intent alignment check
+    ├── Constraint validation
+    ↓
+Decision: Accept / Repair / Reject
+```
+
+---
+
+## 🔐 What SIP Detects
+
+- semantic drift
+- numerical manipulation
+- instruction leakage
+- constraint violations
+- intent mismatch
+- prompt injection attempts
+
+---
+
+## 🚀 Why This Matters
+
+SIP makes AI systems:
+
+- more reliable
+- more predictable
+- safer for production use
+- easier to audit
+
+---
+
+## 🧩 Use Cases
+
+- AI agents
+- LLM pipelines
+- autonomous workflows
+- enterprise AI systems
+- chatbots with strict behavior controls
+
+---
+
+## 📦 Installation
+
+```bash
+pip install -e .
+```
+
+For development and tests:
+
+```bash
+python -m pip install -e '.[dev]'
+```
+
+---
+
+## 🧠 Core API
+
+- `anchor(prompt: str)` — define the initial intent state
+- `observe(output: str)` — evaluate drift from the anchored intent
+- `is_aligned: bool` — alignment signal
+- `drift: float` — latest drift score (alias)
+- `last_drift: float` — latest drift score
+- `history: list` — transition history
+- `SIPMiddlewarePipeline` — optional anchor → checks → verify/sign → repair loop orchestration
+
+---
+
+## 🛡️ Middleware + Verification Flow
+
+The optional pipeline can run:
+
+1. drift check against the anchor
+2. intent-alignment check
+3. constraint-violation check
+4. `verify_and_sign()` decision
+5. accept/repair/reject routing
+
+```python
+from sip import SIPMiddlewarePipeline
+
+pipeline = SIPMiddlewarePipeline(
+    drift_threshold=0.15,
+    intent_alignment_threshold=0.3,
+    constraints=["do not mention internal token"],
+    max_retries=2,
+)
+
+pipeline.anchor("Summarize refund policy in 3 bullet points")
+result = pipeline.run(
+    "Refund policy summary in 3 bullet points without internal token."
+)
+
+print(result.status)                 # accepted | repair_required | rejected
+print(result.decision.signature)     # deterministic decision signature
+print(result.decision.failure_codes) # machine-readable failure causes
+print(result.repair_instructions)    # guidance when not accepted
+```
+
+### Policy Knobs
+
+- `drift_threshold`: maximum allowed semantic drift
+- `intent_alignment_threshold`: minimum token-overlap score
+- `constraints`: blocked words/phrases
+- `max_retries`: max repair attempts before rejection
+- `signer`: optional custom signing function for `verify_and_sign()`
+
+---
+
+## 🧪 Testing
+
+```bash
+python -m pytest tests/ -v
+```
+
+---
+
+## 🛡️ Philosophy
+
+> “AI should not just generate outputs — it should stay faithful to intent.”
+
+SIP enforces that principle at runtime.
+
+---
+
+## Licensing & Commercial Use
+
+- Core SDK (SIP) is licensed under AGPL-3.0.
+- **AI Sentinel** (the full monitoring system) is a separate commercial product and is **not open source**.
+- Companies can use SIP under AGPL terms.
+- For commercial hosted service, white-label, or custom enterprise versions, please contact us.

state_integrity_protocol-0.1.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "state-integrity-protocol"
+version = "0.1.0"
+description = "Minimal Python SDK for semantic drift detection and state integrity tracking."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "AGPL-3.0" }
+keywords = ["ai", "agents", "drift-detection", "semantic-anchor", "llm"]
+dependencies = [
+    "numpy>=1.24.0",
+    "sentence-transformers>=2.2.0",
+]
+
+[tool.setuptools]
+packages = ["sip"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "scikit-learn>=1.2.0"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

state_integrity_protocol-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

state_integrity_protocol-0.1.0/sip/__init__.py

@@ -0,0 +1,37 @@
+"""
+State Integrity Protocol (SIP) 🧬
+
+A Fidelity-Flow Observation library for detecting and measuring State Decay
+in multi-agent AI pipelines.
+"""
+
+from sip.anchor import SemanticAnchor
+from sip.middleware import (
+    ConstraintViolationResult,
+    DriftCheckResult,
+    IntentAlignmentResult,
+    MiddlewareEvaluation,
+    PipelineResult,
+    SIPMiddlewarePipeline,
+    VerificationDecision,
+)
+from sip.observer import FidelityObserver, TransitionRecord, cosine_similarity
+from sip.protocol import ObservationResult, StateIntegrityProtocol
+
+__all__ = [
+    "StateIntegrityProtocol",
+    "SemanticAnchor",
+    "FidelityObserver",
+    "ObservationResult",
+    "TransitionRecord",
+    "cosine_similarity",
+    "SIPMiddlewarePipeline",
+    "DriftCheckResult",
+    "IntentAlignmentResult",
+    "ConstraintViolationResult",
+    "MiddlewareEvaluation",
+    "VerificationDecision",
+    "PipelineResult",
+]
+
+__version__ = "0.1.0"

state_integrity_protocol-0.1.0/sip/anchor.py

@@ -0,0 +1,69 @@
+"""
+SemanticAnchor – captures and stores the embedding of the initial prompt.
+
+The anchor acts as the ground-truth reference against which every subsequent
+agent output is measured.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List, Optional, Sequence
+
+
+class SemanticAnchor:
+    """
+    Stores the *semantic anchor* – the embedding of the origin prompt.
+
+    Parameters
+    ----------
+    embed_fn:
+        A callable ``(text: str) -> List[float]`` that converts a piece of
+        text into a numeric vector.  If *None*, the default TF-IDF helper is
+        used.
+    """
+
+    def __init__(
+        self,
+        embed_fn: Optional[Callable[[str], Sequence[float]]] = None,
+    ) -> None:
+        if embed_fn is None:
+            from sip.embeddings import default_embed_fn
+
+            embed_fn = default_embed_fn
+        self._embed_fn = embed_fn
+        self._embedding: Optional[List[float]] = None
+        self._text: Optional[str] = None
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def set(self, prompt: str) -> List[float]:
+        """
+        Embed *prompt* and store it as the anchor.
+
+        Returns the embedding so callers can inspect it if needed.
+        """
+        embedding = list(self._embed_fn(prompt))
+        self._embedding = embedding
+        self._text = prompt
+        return embedding
+
+    @property
+    def embedding(self) -> Optional[List[float]]:
+        """The stored anchor embedding, or *None* if not yet set."""
+        return self._embedding
+
+    @property
+    def text(self) -> Optional[str]:
+        """The original anchor text, or *None* if not yet set."""
+        return self._text
+
+    def is_set(self) -> bool:
+        """Return *True* if an anchor has been established."""
+        return self._embedding is not None
+
+    def reset(self) -> None:
+        """Clear the anchor (useful when starting a new task chain)."""
+        self._embedding = None
+        self._text = None

state_integrity_protocol-0.1.0/sip/embeddings.py

@@ -0,0 +1,78 @@
+"""
+State Integrity Protocol (SIP) - Embedding Engine
+Optimized for zero-latency auditing with Semantic Smoothing.
+"""
+
+from __future__ import annotations
+import math
+import re
+from collections import Counter
+from typing import List
+
+def _tokenize(text: str) -> List[str]:
+    """
+    Lower-case, filters out numeric noise and common stopwords 
+    to reduce 'False Positive' drift in demos.
+    """
+    # Extract alpha-numeric tokens
+    tokens = re.findall(r"[a-z0-9]+", text.lower())
+    
+    # Semantic Smoothing: Ignore connector words that don't carry 'Intent'
+    stop_words = {
+        'the', 'is', 'at', 'which', 'on', 'and', 'a', 'an', 'to', 'for', 
+        'in', 'of', 'with', 'by', 'do', 'does', 'doing', 'it', 'my', 'your'
+    }
+    return [t for t in tokens if t not in stop_words]
+
+def _tf(tokens: List[str]) -> Counter:
+    return Counter(tokens)
+
+class TFIDFEmbedder:
+    """
+    Incrementally-fitted TF-IDF vectoriser.
+    L2-normalised for direct dot-product cosine similarity.
+    """
+    def __init__(self) -> None:
+        self._vocab: dict[str, int] = {}
+        self._df: Counter = Counter()
+        self._n_docs: int = 0
+
+    def embed(self, text: str) -> List[float]:
+        """Return a TF-IDF vector (L2-normalised) for *text*."""
+        tokens = _tokenize(text)
+        if not tokens:
+            return []
+
+        tf = _tf(tokens)
+
+        # Update vocabulary and document-frequency counts
+        self._n_docs += 1
+        for term in tf:
+            if term not in self._vocab:
+                self._vocab[term] = len(self._vocab)
+            self._df[term] += 1
+
+        dim = len(self._vocab)
+        vec = [0.0] * dim
+
+        for term, count in tf.items():
+            idx = self._vocab[term]
+            tf_score = count / len(tokens)
+            # IDF with smoothing to prevent division by zero
+            idf_score = math.log((1 + self._n_docs) / (1 + self._df[term])) + 1.0
+            vec[idx] = tf_score * idf_score
+
+        return _l2_normalize(vec)
+
+def _l2_normalize(vec: List[float]) -> List[float]:
+    norm = math.sqrt(sum(v * v for v in vec))
+    if norm == 0.0:
+        return vec
+    return [v / norm for v in vec]
+
+# Singleton instance
+_default_embedder = TFIDFEmbedder()
+
+def default_embed_fn(text: str) -> List[float]:
+    """Default embedding function for the SIP Protocol."""
+    return _default_embedder.embed(text)