vinfty 0.1.0__tar.gz

vinfty-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 V∞ Project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

vinfty-0.1.0/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: vinfty
+Version: 0.1.0
+Summary: V∞ — cognitive observability layer for any LLM orchestration framework
+Home-page: https://github.com/twincosmos/vinfty
+Author: V∞ Project
+Author-email: vinfty@twincosmos.dev
+License: MIT
+Keywords: cognitive-architecture observability llm-orchestration v-infty
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# V∞ (vinfty)
+
+**Cognitive observability layer for any LLM orchestration framework.**
+
+Vinfty is a featherweight (~300 lines) Python library that adds cognitive observability to your LLM pipelines — without replacing your existing tools. It measures **ont_self** (self-consistency), tracks **C_ij coupling** (cross-session memory coherence), and detects **HMM s₀/s₁ state transitions** — so you know whether your system is healthy, not just whether it returned a valid JSON.
+
+```
+pip install vinfty
+```
+
+---
+
+## Why?
+
+LangChain, CrewAI, AutoGen — they all solve "how to call LLMs in sequence." None of them answer:
+
+- Is my agent system getting more coherent or more chaotic over time?
+- Are my tool calls producing consistent results or contradicting each other?
+- Is the system in a stable (s₀) or active-search (s₁) mode?
+
+Vinfty adds that layer. It wraps any orchestration framework and gives you a **cognitive dashboard**: ont_self trajectory, coupling matrix, HMM state, palace routing.
+
+## Quick Start
+
+```python
+from vinfty import V9Orchestrator
+
+engine = V9Orchestrator(active_k=100)
+
+# Register any function as a tool → maps to a Palace domain
+@engine.register(palace="P_search")
+def search_web(q: str) -> str:
+    return f"search results for {q}"
+
+@engine.register(palace="P_analysis")
+def calculate(expr: str) -> float:
+    return eval(expr)
+
+# Each call updates the cognitive state
+engine.step("search latest LLM papers", tool=search_web)
+engine.step("how many published this month?", tool=calculate)
+
+# Check system health
+report = engine.report()
+# → {
+#   "ont_self": 0.72,
+#   "hmm_state": "s0"|"s1",
+#   "palace_flow": ["P_query", "P_search", "P_analysis"],
+#   "c_ij_density": 0.34,
+#   "memory_count": 12,
+# }
+```
+
+## Core Concepts
+
+| Concept | What it measures | Analogy |
+|---------|-----------------|---------|
+| **ont_self** | System self-consistency | "Is my agent making consistent decisions?" |
+| **C_ij** | Cross-session memory coupling | "Do past decisions influence present ones coherently?" |
+| **HMM s₀/s₁** | Cognitive mode | "Is the system in stable execution (s₀) or active exploration (s₁)?" |
+| **Palace** | Functional domain | "Which cognitive domain is each tool call serving?" |
+
+## Adapters
+
+Vinfty ships with adapters for common frameworks:
+
+```python
+# LangChain adapter
+from vinfty.adapters.langchain import LangChainAdapter
+
+adapter = LangChainAdapter(agent)
+report = adapter.run_with_observability(user_query)
+# Same result as agent.run(), plus cognitive report
+```
+
+## No LLM Required
+
+Vinfty is pure symbolic computation — no API keys, no GPU, no model weights. The cognitive metrics are derived from the **structure** of your tool calls and memory traces, not from the content of LLM responses.
+
+## License
+
+MIT

vinfty-0.1.0/README.md

@@ -0,0 +1,82 @@
+# V∞ (vinfty)
+
+**Cognitive observability layer for any LLM orchestration framework.**
+
+Vinfty is a featherweight (~300 lines) Python library that adds cognitive observability to your LLM pipelines — without replacing your existing tools. It measures **ont_self** (self-consistency), tracks **C_ij coupling** (cross-session memory coherence), and detects **HMM s₀/s₁ state transitions** — so you know whether your system is healthy, not just whether it returned a valid JSON.
+
+```
+pip install vinfty
+```
+
+---
+
+## Why?
+
+LangChain, CrewAI, AutoGen — they all solve "how to call LLMs in sequence." None of them answer:
+
+- Is my agent system getting more coherent or more chaotic over time?
+- Are my tool calls producing consistent results or contradicting each other?
+- Is the system in a stable (s₀) or active-search (s₁) mode?
+
+Vinfty adds that layer. It wraps any orchestration framework and gives you a **cognitive dashboard**: ont_self trajectory, coupling matrix, HMM state, palace routing.
+
+## Quick Start
+
+```python
+from vinfty import V9Orchestrator
+
+engine = V9Orchestrator(active_k=100)
+
+# Register any function as a tool → maps to a Palace domain
+@engine.register(palace="P_search")
+def search_web(q: str) -> str:
+    return f"search results for {q}"
+
+@engine.register(palace="P_analysis")
+def calculate(expr: str) -> float:
+    return eval(expr)
+
+# Each call updates the cognitive state
+engine.step("search latest LLM papers", tool=search_web)
+engine.step("how many published this month?", tool=calculate)
+
+# Check system health
+report = engine.report()
+# → {
+#   "ont_self": 0.72,
+#   "hmm_state": "s0"|"s1",
+#   "palace_flow": ["P_query", "P_search", "P_analysis"],
+#   "c_ij_density": 0.34,
+#   "memory_count": 12,
+# }
+```
+
+## Core Concepts
+
+| Concept | What it measures | Analogy |
+|---------|-----------------|---------|
+| **ont_self** | System self-consistency | "Is my agent making consistent decisions?" |
+| **C_ij** | Cross-session memory coupling | "Do past decisions influence present ones coherently?" |
+| **HMM s₀/s₁** | Cognitive mode | "Is the system in stable execution (s₀) or active exploration (s₁)?" |
+| **Palace** | Functional domain | "Which cognitive domain is each tool call serving?" |
+
+## Adapters
+
+Vinfty ships with adapters for common frameworks:
+
+```python
+# LangChain adapter
+from vinfty.adapters.langchain import LangChainAdapter
+
+adapter = LangChainAdapter(agent)
+report = adapter.run_with_observability(user_query)
+# Same result as agent.run(), plus cognitive report
+```
+
+## No LLM Required
+
+Vinfty is pure symbolic computation — no API keys, no GPU, no model weights. The cognitive metrics are derived from the **structure** of your tool calls and memory traces, not from the content of LLM responses.
+
+## License
+
+MIT

vinfty-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"

vinfty-0.1.0/setup.cfg

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

vinfty-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="vinfty",
+    version="0.1.0",
+    description="V∞ — cognitive observability layer for any LLM orchestration framework",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="V∞ Project",
+    author_email="vinfty@twincosmos.dev",
+    url="https://github.com/twincosmos/vinfty",
+    license="MIT",
+    packages=find_packages(),
+    python_requires=">=3.10",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    ],
+    keywords="cognitive-architecture observability llm-orchestration v-infty",
+)

vinfty-0.1.0/tests/test_core.py

@@ -0,0 +1,102 @@
+import sys
+sys.path.insert(0, "..")
+
+from vinfty.core import V9Orchestrator, _HMM
+
+
+def test_empty_ont_self():
+    engine = V9Orchestrator(active_k=50)
+    assert engine.ont_self() == 0.0, "empty → ont_self = 0"
+    print("  ✅ empty ont_self")
+
+
+def test_single_memory():
+    engine = V9Orchestrator(active_k=50)
+    engine.step("hello", palace="P_test")
+    assert engine.ont_self() == 0.0, "single memory → ont_self = 0 (no pairs)"
+    print("  ✅ single memory ont_self")
+
+
+def test_same_palace():
+    engine = V9Orchestrator(active_k=50)
+    for i in range(5):
+        engine.step(f"item {i}", palace="P_fixed")
+    assert engine.ont_self() >= 0.5, f"same palace → high ont_self (got {engine.ont_self():.4f})"
+    print(f"  ✅ same palace ont_self = {engine.ont_self():.4f}")
+
+
+def test_diff_palace():
+    engine = V9Orchestrator(active_k=50)
+    for i in range(5):
+        engine.step(f"item {i}", palace=f"P_{i}")
+    assert engine.ont_self() < 0.1, "diff palaces → near 0 ont_self"
+    print(f"  ✅ diff palace ont_self = {engine.ont_self():.4f}")
+
+
+def test_hmm_initial():
+    hmm = _HMM()
+    assert hmm.state == "s0", "init state = s0"
+    assert hmm.posterior_s1 == 0.0, "init posterior = 0"
+    print("  ✅ HMM initial state")
+
+
+def test_hmm_update():
+    hmm = _HMM()
+    hmm.update(0.9)  # large delta ratio → s1
+    assert hmm.state == "s1", "high delta ratio → s1"
+    hmm.update(0.0)  # small delta ratio → s0
+    assert hmm.state == "s0", "low delta ratio → s0"
+    print(f"  ✅ HMM state transition {hmm.state}")
+
+
+def test_register_decorator():
+    engine = V9Orchestrator()
+    @engine.register(palace="P_test")
+    def foo(): pass
+    assert "foo" in engine._palace_registry
+    assert engine._palace_registry["foo"]["palace"] == "P_test"
+    print("  ✅ register decorator")
+
+
+def test_report():
+    engine = V9Orchestrator(active_k=50)
+    for i in range(5):
+        engine.step(f"item {i}", palace="P_fixed")
+    r = engine.report()
+    assert "ont_self" in r
+    assert "hmm_state" in r
+    assert "c_ij_density" in r
+    assert r["memory_count"] == 5
+    print(f"  ✅ report keys={list(r.keys())}")
+
+
+def test_trace():
+    engine = V9Orchestrator(active_k=50)
+    engine.step("hello", palace="P_test")
+    t = engine.trace()
+    assert len(t) == 1
+    assert t[0]["palace"] == "P_test"
+    print("  ✅ trace")
+
+
+def test_active_pool_pruning():
+    engine = V9Orchestrator(active_k=10)
+    for i in range(20):
+        engine.step(f"item {i}", palace="P_fixed")
+    assert len(engine.memories) == 10
+    assert len(engine.archive) == 10
+    print("  ✅ active pool pruning")
+
+
+if __name__ == "__main__":
+    test_empty_ont_self()
+    test_single_memory()
+    test_same_palace()
+    test_diff_palace()
+    test_hmm_initial()
+    test_hmm_update()
+    test_register_decorator()
+    test_report()
+    test_trace()
+    test_active_pool_pruning()
+    print("\n🎯 10/10 tests passed")

vinfty-0.1.0/vinfty/__init__.py

@@ -0,0 +1,5 @@
+"""vinfty — cognitive observability layer for any LLM orchestration framework."""
+
+from .core import V9Orchestrator
+
+__version__ = "0.1.0"

vinfty-0.1.0/vinfty/adapters/__init__.py

@@ -0,0 +1,3 @@
+"""vinfty.adapters — adapters for common LLM orchestration frameworks."""
+
+from .langchain import LangChainAdapter

vinfty-0.1.0/vinfty/adapters/langchain.py

@@ -0,0 +1,36 @@
+"""
+vinfty.adapters.langchain — wrap a LangChain agent with cognitive observability.
+
+Usage:
+    from vinfty.adapters.langchain import LangChainAdapter
+
+    adapter = LangChainAdapter(agent)
+    result, report = adapter.run("query")
+    print(report["ont_self"])
+"""
+
+from typing import Any, Optional
+
+from vinfty.core import V9Orchestrator
+
+
+class LangChainAdapter:
+    """Wraps a LangChain agent and adds V9 cognitive observability."""
+
+    def __init__(self, agent: Any, active_k: int = 100):
+        self.agent = agent
+        self.cog = V9Orchestrator(active_k=active_k)
+
+    def run(self, query: str, **kwargs) -> tuple[str, dict]:
+        """Run query through agent, return (result, cognitive_report)."""
+        self.cog.step(query, palace="P_query")
+        result = self.agent.run(query, **kwargs)
+        self.cog.step(result, palace="P_response")
+        return result, self.cog.report()
+
+    def run_with_observability(self, query: str, **kwargs) -> str:
+        """Run and print cognitive report alongside result."""
+        result, report = self.run(query, **kwargs)
+        print(f"[V∞] ont_self={report['ont_self']}  state={report['hmm_state']}  "
+              f"palaces={report['palace_count']}  c_density={report['c_ij_density']}")
+        return result

vinfty-0.1.0/vinfty/core.py

@@ -0,0 +1,167 @@
+"""
+vinfty.core — V9Orchestrator: cognitive state machine for tool-call observation.
+
+No LLM dependency. Pure symbolic computation:
+  - ont_self = Σ C_ij · I_j (self-consistency)
+  - C_ij = 1 when memories share a Palace label
+  - HMM K=2 tracks s₀ (stable) / s₁ (searching) state
+  - Palace routing assigns tool calls to cognitive domains
+"""
+
+import math
+import json
+from collections import defaultdict
+from typing import Callable, Optional
+
+
+class V9Orchestrator:
+    """Lightweight cognitive engine tracking ont_self, C_ij coupling, HMM state."""
+
+    def __init__(self, active_k: int = 100):
+        self.active_k = active_k
+        self.memories: list[dict] = []
+        self.archive: list[dict] = []
+        self._palace_registry: dict[str, Callable] = {}
+        self._hmm = _HMM()
+        self._last_scan = -1
+
+    # ── tool registration ──
+
+    def register(self, palace: str = "P_generic"):
+        """Decorator: register a function as a tool belonging to a Palace domain."""
+        def decorator(fn):
+            self._palace_registry[fn.__name__] = {"fn": fn, "palace": palace}
+            return fn
+        return decorator
+
+    def register_tool(self, name: str, fn: Callable, palace: str = "P_generic"):
+        """Register a tool by name."""
+        self._palace_registry[name] = {"fn": fn, "palace": palace}
+
+    # ── step / run ──
+
+    def step(self, content: str, tool: Optional[Callable] = None, **extra):
+        """Process one interaction: store memory, update coupling, run HMM."""
+        mem = {
+            "content": content,
+            "palace": extra.get("palace", self._resolve_palace(content, tool)),
+            "confidence": extra.get("confidence", 0.5),
+            "tick": len(self.memories) + len(self.archive),
+        }
+        self.memories.append(mem)
+        # active pool pruning
+        if len(self.memories) > self.active_k:
+            excess = self.memories[:-self.active_k]
+            self.archive.extend(excess)
+            self.memories = self.memories[-self.active_k:]
+            if len(self.archive) > 2000:
+                self.archive = self.archive[-2000:]
+        # HMM update (convenience: rescan every step)
+        self._scan_hmm()
+
+    def run(self, tasks: list[str], **extra):
+        """Process multiple string tasks in sequence."""
+        for t in tasks:
+            self.step(t, **extra)
+
+    # ── report ──
+
+    def report(self) -> dict:
+        """Return current cognitive state summary."""
+        ont = self.ont_self()
+        c_density = self._coupling_density()
+        palace_counts = self._palace_distribution()
+        return {
+            "ont_self": round(ont, 4),
+            "c_ij_density": round(c_density, 4),
+            "hmm_state": self._hmm.state,
+            "hmm_s1_posterior": round(self._hmm.posterior_s1, 4),
+            "memory_count": len(self.memories),
+            "archive_count": len(self.archive),
+            "palace_count": len(palace_counts),
+            "palace_flow": [m.get("palace", "?") for m in self.memories[-5:]],
+            "palace_distribution": palace_counts,
+        }
+
+    def ont_self(self) -> float:
+        """Compute self-consistency: mean C_ij · I_j across all active pairs."""
+        mems = self.memories
+        n = len(mems)
+        if n < 2:
+            return 0.0
+        total = 0.0
+        pairs = 0
+        for i in range(n):
+            for j in range(i + 1, n):
+                c = 1.0 if mems[i].get("palace") == mems[j].get("palace") else 0.0
+                ii = mems[i].get("confidence", 0.5)
+                ij = mems[j].get("confidence", 0.5)
+                total += c * (ii + ij) / 2.0
+                pairs += 1
+        return total / pairs if pairs else 0.0
+
+    # ── trace ──
+
+    def trace(self) -> list[dict]:
+        """Return full memory history with HMM labels for inspection."""
+        return [
+            {"content": m["content"][:60], "palace": m.get("palace"), "tick": m.get("tick")}
+            for m in (self.memories + self.archive)
+        ]
+
+    # ── internals ──
+
+    def _resolve_palace(self, content: str, tool: Optional[Callable] = None) -> str:
+        if tool and tool.__name__ in self._palace_registry:
+            return self._palace_registry[tool.__name__]["palace"]
+        # fallback: hash-based palace for unrecognized content
+        h = hash(content) & 0xFFFF
+        return f"P_hash_{h % 64:02d}"
+
+    def _coupling_density(self) -> float:
+        mems = self.memories
+        if len(mems) < 2:
+            return 0.0
+        same = sum(1 for i in range(len(mems)) for j in range(i + 1, len(mems))
+                   if mems[i].get("palace") == mems[j].get("palace"))
+        total = len(mems) * (len(mems) - 1) / 2.0
+        return same / total if total else 0.0
+
+    def _palace_distribution(self) -> dict:
+        counts = defaultdict(int)
+        for m in self.memories:
+            counts[m.get("palace", "?")] += 1
+        return dict(sorted(counts.items(), key=lambda x: -x[1]))
+
+    def _scan_hmm(self):
+        """Update HMM state from memory delta distribution."""
+        mems = self.memories
+        if len(mems) < 3:
+            return
+        ticks = [m.get("tick", i) for i, m in enumerate(mems)]
+        deltas = [ticks[i] - ticks[i - 1] for i in range(1, len(ticks))]
+        # simple empirical update
+        mean_delta = sum(deltas) / len(deltas) if deltas else 1.0
+        large_delta_ratio = sum(1 for d in deltas if d > mean_delta * 1.5) / len(deltas) if deltas else 0.0
+        self._hmm.update(large_delta_ratio)
+
+
+class _HMM:
+    """Minimal 2-state HMM tracking s₀ (stable) / s₁ (searching)."""
+
+    def __init__(self):
+        self.state = "s0"
+        self.posterior_s1 = 0.0
+        self._A = [[0.85, 0.15], [0.20, 0.80]]  # transition matrix
+        self._B = [[0.70, 0.30], [0.25, 0.75]]  # emission (s0 prefers small-delta, s1 prefers large)
+
+    def update(self, large_ratio: float):
+        # simple forward pass
+        like_s0 = self._B[0][0] * (1 - large_ratio) + self._B[0][1] * large_ratio
+        like_s1 = self._B[1][0] * (1 - large_ratio) + self._B[1][1] * large_ratio
+        total = like_s0 + like_s1
+        self.posterior_s1 = like_s1 / total if total > 0 else 0.5
+        if self.state == "s0":
+            self.state = "s1" if self.posterior_s1 > 0.55 else "s0"
+        else:
+            self.state = "s0" if self.posterior_s1 < 0.40 else "s1"

vinfty-0.1.0/vinfty.egg-info/PKG-INFO

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: vinfty
+Version: 0.1.0
+Summary: V∞ — cognitive observability layer for any LLM orchestration framework
+Home-page: https://github.com/twincosmos/vinfty
+Author: V∞ Project
+Author-email: vinfty@twincosmos.dev
+License: MIT
+Keywords: cognitive-architecture observability llm-orchestration v-infty
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary
+
+# V∞ (vinfty)
+
+**Cognitive observability layer for any LLM orchestration framework.**
+
+Vinfty is a featherweight (~300 lines) Python library that adds cognitive observability to your LLM pipelines — without replacing your existing tools. It measures **ont_self** (self-consistency), tracks **C_ij coupling** (cross-session memory coherence), and detects **HMM s₀/s₁ state transitions** — so you know whether your system is healthy, not just whether it returned a valid JSON.
+
+```
+pip install vinfty
+```
+
+---
+
+## Why?
+
+LangChain, CrewAI, AutoGen — they all solve "how to call LLMs in sequence." None of them answer:
+
+- Is my agent system getting more coherent or more chaotic over time?
+- Are my tool calls producing consistent results or contradicting each other?
+- Is the system in a stable (s₀) or active-search (s₁) mode?
+
+Vinfty adds that layer. It wraps any orchestration framework and gives you a **cognitive dashboard**: ont_self trajectory, coupling matrix, HMM state, palace routing.
+
+## Quick Start
+
+```python
+from vinfty import V9Orchestrator
+
+engine = V9Orchestrator(active_k=100)
+
+# Register any function as a tool → maps to a Palace domain
+@engine.register(palace="P_search")
+def search_web(q: str) -> str:
+    return f"search results for {q}"
+
+@engine.register(palace="P_analysis")
+def calculate(expr: str) -> float:
+    return eval(expr)
+
+# Each call updates the cognitive state
+engine.step("search latest LLM papers", tool=search_web)
+engine.step("how many published this month?", tool=calculate)
+
+# Check system health
+report = engine.report()
+# → {
+#   "ont_self": 0.72,
+#   "hmm_state": "s0"|"s1",
+#   "palace_flow": ["P_query", "P_search", "P_analysis"],
+#   "c_ij_density": 0.34,
+#   "memory_count": 12,
+# }
+```
+
+## Core Concepts
+
+| Concept | What it measures | Analogy |
+|---------|-----------------|---------|
+| **ont_self** | System self-consistency | "Is my agent making consistent decisions?" |
+| **C_ij** | Cross-session memory coupling | "Do past decisions influence present ones coherently?" |
+| **HMM s₀/s₁** | Cognitive mode | "Is the system in stable execution (s₀) or active exploration (s₁)?" |
+| **Palace** | Functional domain | "Which cognitive domain is each tool call serving?" |
+
+## Adapters
+
+Vinfty ships with adapters for common frameworks:
+
+```python
+# LangChain adapter
+from vinfty.adapters.langchain import LangChainAdapter
+
+adapter = LangChainAdapter(agent)
+report = adapter.run_with_observability(user_query)
+# Same result as agent.run(), plus cognitive report
+```
+
+## No LLM Required
+
+Vinfty is pure symbolic computation — no API keys, no GPU, no model weights. The cognitive metrics are derived from the **structure** of your tool calls and memory traces, not from the content of LLM responses.
+
+## License
+
+MIT

vinfty-0.1.0/vinfty.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+tests/test_core.py
+vinfty/__init__.py
+vinfty/core.py
+vinfty.egg-info/PKG-INFO
+vinfty.egg-info/SOURCES.txt
+vinfty.egg-info/dependency_links.txt
+vinfty.egg-info/top_level.txt
+vinfty/adapters/__init__.py
+vinfty/adapters/langchain.py

vinfty-0.1.0/vinfty.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

vinfty-0.1.0/vinfty.egg-info/top_level.txt

@@ -0,0 +1 @@
+vinfty