secondwind 0.1.0__py3-none-win_amd64.whl

secondwind/__init__.py

@@ -0,0 +1,204 @@
+"""secondwind: lossless, provable, composable LLM context compression.
+
+Thin ctypes binding over the bundled C ABI (no native extension); the first caller of a C ABI
+every language calls the same way.
+"""
+
+import ctypes
+import json
+import os
+
+
+def _library_path() -> str:
+    if os.environ.get("SECONDWIND_LIB"):
+        return os.environ["SECONDWIND_LIB"]
+    here = os.path.dirname(__file__)
+    names = ("libsecondwind.dylib", "libsecondwind.so", "secondwind.dll")
+    # Bundled inside the wheel.
+    for name in names:
+        bundled = os.path.join(here, "_lib", name)
+        if os.path.exists(bundled):
+            return bundled
+    # Dev fallback: source-checkout cargo target dir.
+    target = os.path.join(here, "..", "..", "..", "target", "release")
+    for name in names:
+        dev = os.path.join(target, name)
+        if os.path.exists(dev):
+            return dev
+    raise OSError("secondwind native library not found; build it or set SECONDWIND_LIB")
+
+
+_lib = ctypes.CDLL(_library_path())
+_lib.sw_abi_version.restype = ctypes.c_uint32
+for _fn in ("sw_compress", "sw_verify"):
+    f = getattr(_lib, _fn)
+    f.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.POINTER(ctypes.c_size_t)]
+    f.restype = ctypes.POINTER(ctypes.c_ubyte)
+_lib.sw_free.argtypes = [ctypes.POINTER(ctypes.c_ubyte), ctypes.c_size_t]
+_lib.sw_session_new.argtypes = [ctypes.c_char_p, ctypes.c_size_t]
+_lib.sw_session_new.restype = ctypes.c_void_p
+_lib.sw_session_free.argtypes = [ctypes.c_void_p]
+_lib.sw_rewrite.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t, ctypes.POINTER(ctypes.c_size_t)]
+_lib.sw_rewrite.restype = ctypes.POINTER(ctypes.c_ubyte)
+
+# Host offload backend: put(ctx, id, id_len, val, val_len) -> int; get(ctx, id, id_len, out_len) -> bytes*.
+_PUT = ctypes.CFUNCTYPE(
+    ctypes.c_int, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_size_t,
+    ctypes.POINTER(ctypes.c_ubyte), ctypes.c_size_t,
+)
+_GET = ctypes.CFUNCTYPE(
+    ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_size_t,
+    ctypes.POINTER(ctypes.c_size_t),
+)
+_lib.sw_session_new_with_store.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_void_p, _PUT, _GET]
+_lib.sw_session_new_with_store.restype = ctypes.c_void_p
+
+# Host codec: encode/decode take input bytes, return an output ptr (len via out_len) or null; same
+# shape as the store's get callback.
+_CODEC = ctypes.CFUNCTYPE(
+    ctypes.c_void_p, ctypes.c_void_p, ctypes.POINTER(ctypes.c_ubyte), ctypes.c_size_t,
+    ctypes.POINTER(ctypes.c_size_t),
+)
+_lib.sw_session_new_with_codec.argtypes = [ctypes.c_char_p, ctypes.c_size_t, ctypes.c_void_p, _CODEC, _CODEC]
+_lib.sw_session_new_with_codec.restype = ctypes.c_void_p
+
+
+def _call(fn, payload: dict) -> dict:
+    data = json.dumps(payload).encode("utf-8")
+    out_len = ctypes.c_size_t(0)
+    ptr = fn(data, len(data), ctypes.byref(out_len))
+    try:
+        return json.loads(ctypes.string_at(ptr, out_len.value))
+    finally:
+        _lib.sw_free(ptr, out_len.value)
+
+
+def abi_version() -> int:
+    return _lib.sw_abi_version()
+
+
+def compress(block: str, model: str | None = None) -> dict:
+    """Losslessly compress one tool-output block. Returns the outcome dict."""
+    payload = {"block": block}
+    if model:
+        payload["model"] = model
+    return _call(_lib.sw_compress, payload)
+
+
+def verify(wire: str, cert_hash: str) -> bool:
+    """Independently confirm a wire is lossless against its certificate hash (no trust required)."""
+    return _call(_lib.sw_verify, {"wire": wire, "hash": cert_hash}).get("ok", False)
+
+
+class Session:
+    """Per-conversation handle: freeze memory keeps resends byte-identical so only aged blocks
+    offload. `home` books ledger events for `secondwind proof --home <dir>`."""
+
+    def __init__(self, resolver=None, offload_dir=None, home=None, store=None, proposers=True, codec=None):
+        """`store`: any object with put(id, value) -> bool and get(id) -> str | None, so offload can
+        be backed by Redis/S3/a database. `proposers` toggles the best-of-N codec search (on; off is a
+        cost/latency choice, output is proven lossless either way). `codec`: any object with
+        encode(text) and decode(wire); it competes in the search and is dropped unless
+        decode(encode(x)) == x per block."""
+        config: dict = {"proposers": bool(proposers)}
+        if resolver:
+            config["resolver"] = resolver
+        if offload_dir:
+            config["offload_dir"] = offload_dir
+        if home:
+            config["home"] = home
+        data = json.dumps(config).encode("utf-8")
+        if codec is not None:
+            self._ptr = self._open_with_codec(data, codec)
+        elif store is None:
+            self._ptr = _lib.sw_session_new(data, len(data))
+        else:
+            self._ptr = self._open_with_store(data, store)
+        self._totals = {"requests": 0, "blocks_rewritten": 0, "blocks_first_seen": 0, "tokens_saved": 0}
+
+    def _open_with_codec(self, config: bytes, codec):
+        self._codec = codec
+        self._enc_buf = None  # keep each result alive until secondwind copies it
+        self._dec_buf = None
+
+        def side(method, hold):
+            def cb(_ctx, in_ptr, in_len, out_len):
+                try:
+                    result = method(ctypes.string_at(in_ptr, in_len).decode("utf-8"))
+                except Exception:
+                    result = None
+                if not isinstance(result, str):
+                    out_len[0] = 0
+                    return None
+                raw = result.encode("utf-8")
+                buf = (ctypes.c_ubyte * len(raw)).from_buffer_copy(raw)
+                setattr(self, hold, buf)
+                out_len[0] = len(raw)
+                return ctypes.addressof(buf)
+
+            return cb
+
+        self._enc_cb = _CODEC(side(codec.encode, "_enc_buf"))
+        self._dec_cb = _CODEC(side(codec.decode, "_dec_buf"))
+        return _lib.sw_session_new_with_codec(config, len(config), None, self._enc_cb, self._dec_cb)
+
+    def _open_with_store(self, config: bytes, store):
+        self._store = store
+        self._get_buf = None  # keeps the last get result alive until the next call
+
+        def put_cb(_ctx, id_ptr, id_len, val_ptr, val_len):
+            try:
+                key = ctypes.string_at(id_ptr, id_len).decode("utf-8")
+                val = ctypes.string_at(val_ptr, val_len).decode("utf-8")
+                return 1 if store.put(key, val) else 0
+            except Exception:
+                return 0
+
+        def get_cb(_ctx, id_ptr, id_len, out_len):
+            try:
+                key = ctypes.string_at(id_ptr, id_len).decode("utf-8")
+                val = store.get(key)
+            except Exception:
+                val = None
+            if val is None:
+                out_len[0] = 0
+                return None
+            raw = val.encode("utf-8")
+            self._get_buf = (ctypes.c_ubyte * len(raw)).from_buffer_copy(raw)
+            out_len[0] = len(raw)
+            return ctypes.addressof(self._get_buf)
+
+        # Keep the callback objects alive on self, or they are garbage-collected and the FFI crashes.
+        self._put_cb = _PUT(put_cb)
+        self._get_cb = _GET(get_cb)
+        return _lib.sw_session_new_with_store(config, len(config), None, self._put_cb, self._get_cb)
+
+    def rewrite(self, request: dict) -> dict:
+        """Compress every tool-output block in a whole LLM request. Returns {"request", "stats"}."""
+        data = json.dumps(request).encode("utf-8")
+        out_len = ctypes.c_size_t(0)
+        ptr = _lib.sw_rewrite(self._ptr, data, len(data), ctypes.byref(out_len))
+        try:
+            out = json.loads(ctypes.string_at(ptr, out_len.value))
+        finally:
+            _lib.sw_free(ptr, out_len.value)
+        stats = out.get("stats", {})
+        self._totals["requests"] += 1
+        for key in ("blocks_rewritten", "blocks_first_seen", "tokens_saved"):
+            self._totals[key] += stats.get(key, 0)
+        return out
+
+    def stats(self) -> dict:
+        """Running totals for this session (no proxy needed)."""
+        return dict(self._totals)
+
+    def close(self):
+        if self._ptr:
+            _lib.sw_session_free(self._ptr)
+            self._ptr = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.close()

secondwind/agno.py

@@ -0,0 +1,52 @@
+"""Agno integration: lossless replacement for Agno's tool-result compression.
+
+    from agno.agent import Agent
+    from secondwind.agno import SecondwindCompressionManager
+
+    agent = Agent(
+        model=...,
+        compress_tool_results=True,
+        compression_manager=SecondwindCompressionManager(compress_tool_results=True),
+    )
+
+Keeps Agno's gating (when/which results to compress) but swaps its lossy per-result LLM summarizer
+for secondwind: lossless, no model call. Any failure returns None so Agno keeps the original.
+"""
+
+try:
+    from agno.compression import CompressionManager as _CompressionManager
+
+    _AGNO = True
+except ImportError:  # agno optional
+    _CompressionManager = object
+    _AGNO = False
+
+from . import Session
+
+
+class SecondwindCompressionManager(_CompressionManager):
+    _sw_session = None
+
+    def _session(self):
+        if self._sw_session is None:
+            self._sw_session = Session()
+        return self._sw_session
+
+    def _compress_lossless(self, content):
+        if not isinstance(content, str) or not content:
+            return None
+        try:
+            out = self._session().rewrite(
+                {"model": "", "messages": [{"role": "tool", "tool_call_id": "t", "content": content}]}
+            )
+            new = out["request"]["messages"][0]["content"]
+            return new if isinstance(new, str) and new != content else None
+        except Exception:  # fail open: Agno keeps the original
+            return None
+
+    # Override both engine hooks so Agno's compress()/acompress() call secondwind, not an LLM.
+    def _compress_tool_result(self, tool_msg, *args, **kwargs):
+        return self._compress_lossless(getattr(tool_msg, "content", None))
+
+    async def _acompress_tool_result(self, tool_msg, *args, **kwargs):
+        return self._compress_lossless(getattr(tool_msg, "content", None))

secondwind/asgi.py

@@ -0,0 +1,81 @@
+"""ASGI middleware: compress LLM tool outputs for a self-hosted gateway with one line.
+
+    from secondwind.asgi import SecondwindMiddleware
+    app.add_middleware(SecondwindMiddleware)          # Starlette / FastAPI
+    # or wrap any ASGI app directly:  app = SecondwindMiddleware(app)
+
+Rewrites tool outputs in a JSON chat-completion body in-process before your app forwards upstream.
+Only touches POST requests whose JSON body has `messages`; any failure falls back to the original body.
+"""
+
+import json
+
+from . import Session
+
+
+async def _read_body(receive):
+    chunks = []
+    while True:
+        message = await receive()
+        if message["type"] == "http.request":
+            chunks.append(message.get("body", b""))
+            if not message.get("more_body", False):
+                break
+        elif message["type"] == "http.disconnect":
+            break
+    return b"".join(chunks)
+
+
+def _replay(body):
+    # Replay the (possibly rewritten) body as one request event, then disconnect.
+    done = False
+
+    async def receive():
+        nonlocal done
+        if not done:
+            done = True
+            return {"type": "http.request", "body": body, "more_body": False}
+        return {"type": "http.disconnect"}
+
+    return receive
+
+
+class SecondwindMiddleware:
+    def __init__(self, app, resolver=None, home=None, paths=None):
+        """`paths`: a prefix (or tuple) to limit rewriting to your LLM route; default touches any
+        POST whose JSON body has `messages`."""
+        self.app = app
+        self._session = Session(resolver=resolver, home=home)
+        self._paths = (paths,) if isinstance(paths, str) else tuple(paths) if paths else None
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] != "http" or scope.get("method") != "POST":
+            return await self.app(scope, receive, send)
+        if self._paths and not scope["path"].startswith(self._paths):
+            return await self.app(scope, receive, send)
+
+        body = await _read_body(receive)
+        new_body = self._maybe_rewrite(body)
+        if new_body is body:
+            return await self.app(scope, _replay(body), send)
+
+        # Body length changed: correct Content-Length before the app reads it.
+        headers = [(k, v) for (k, v) in scope["headers"] if k.lower() != b"content-length"]
+        headers.append((b"content-length", str(len(new_body)).encode()))
+        return await self.app({**scope, "headers": headers}, _replay(new_body), send)
+
+    def _maybe_rewrite(self, body):
+        try:
+            payload = json.loads(body)
+        except Exception:
+            return body
+        if not isinstance(payload, dict) or "messages" not in payload:
+            return body
+        try:
+            out = self._session.rewrite(payload)
+            return json.dumps(out["request"]).encode("utf-8")
+        except Exception:  # never break the request
+            return body
+
+    def close(self):
+        self._session.close()

secondwind/cursor.py

@@ -0,0 +1,70 @@
+"""Cursor integration: a postToolUse hook that losslessly compresses MCP tool output.
+
+Cursor's one supported output-rewrite seam is `postToolUse` -> `updated_mcp_tool_output`. This module
+IS that hook: reads Cursor's JSON on stdin, compresses the tool output, writes the replacement on
+stdout. Any error or non-compressible output returns {} so the model sees the original.
+
+Configure ~/.cursor/hooks.json (or a project .cursor/hooks.json):
+
+    {
+      "version": 1,
+      "hooks": { "postToolUse": [ { "command": "python -m secondwind.cursor" } ] }
+    }
+
+For chat / plan mode (a different seam), point Cursor's "Override OpenAI Base URL" at a running
+`secondwind serve` proxy. Cursor's hook field names are beta and version-dependent; if yours differ,
+set FIELD_IN / FIELD_OUT below.
+"""
+
+import json
+import sys
+
+from . import compress
+
+FIELD_IN = "tool_output"
+FIELD_OUT = "updated_mcp_tool_output"
+
+
+def _compress_text(text):
+    if not isinstance(text, str) or not text:
+        return None
+    try:
+        out = compress(text)
+        if out.get("kind") == "compressed":
+            return out["wire"]
+    except Exception:
+        pass
+    return None
+
+
+def rewrite_output(payload):
+    """The hook's stdout for a postToolUse payload, or {} to leave the tool output unchanged."""
+    output = payload.get(FIELD_IN)
+    if isinstance(output, str):
+        wire = _compress_text(output)
+        return {FIELD_OUT: wire} if wire else {}
+    # MCP content-block shape: {"content": [{"text": ...}, ...]}
+    if isinstance(output, dict) and isinstance(output.get("content"), list):
+        content = [dict(block) if isinstance(block, dict) else block for block in output["content"]]
+        changed = False
+        for block in content:
+            if isinstance(block, dict) and isinstance(block.get("text"), str):
+                wire = _compress_text(block["text"])
+                if wire:
+                    block["text"] = wire
+                    changed = True
+        return {FIELD_OUT: {**output, "content": content}} if changed else {}
+    return {}
+
+
+def main():
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        sys.stdout.write("{}")
+        return
+    json.dump(rewrite_output(payload), sys.stdout)
+
+
+if __name__ == "__main__":
+    main()

secondwind/langchain.py

@@ -0,0 +1,83 @@
+"""LangChain and LangGraph integration: compress tool-message outputs losslessly, two ways.
+
+LCEL chain:
+
+    from secondwind.langchain import compress_tool_outputs
+    chain = compress_tool_outputs() | model      # model = any LangChain chat model
+
+LangGraph agent loop:
+
+    from langgraph.prebuilt import create_react_agent
+    from secondwind.langchain import compress_pre_model_hook
+    agent = create_react_agent(model, tools, pre_model_hook=compress_pre_model_hook())
+
+Both convert to the OpenAI shape, rewrite tool outputs through a session (resends stay byte-identical,
+only aged blocks offload), and map compressed content back by tool_call_id. Any failure returns the
+messages unchanged, so neither seam can break a chain or agent.
+"""
+
+from . import Session
+
+
+def _rewrite_tool_messages(sess, model, messages):
+    """New message list with only ToolMessage string content compressed; others are the original
+    object. On failure returns the input list itself, so list identity signals whether anything changed."""
+    from langchain_core.messages import ToolMessage, convert_to_openai_messages
+
+    try:
+        openai_messages = convert_to_openai_messages(messages)
+        out = sess.rewrite({"model": model, "messages": openai_messages})
+        rewritten = out.get("request", {}).get("messages", [])
+    except Exception:  # never break the caller
+        return messages
+
+    by_id = {
+        m.get("tool_call_id"): m.get("content")
+        for m in rewritten
+        if isinstance(m, dict) and m.get("role") == "tool"
+    }
+    result = []
+    for message in messages:
+        new_content = by_id.get(getattr(message, "tool_call_id", None))
+        if (
+            isinstance(message, ToolMessage)
+            and isinstance(message.content, str)
+            and isinstance(new_content, str)
+            and new_content != message.content
+        ):
+            result.append(message.model_copy(update={"content": new_content}))
+        else:
+            result.append(message)
+    return result
+
+
+def compress_tool_outputs(session=None, model="gpt-4o", resolver=None):
+    """LCEL runnable that compresses the tool messages passing through it, so the downstream model
+    in `compress_tool_outputs() | model` reads the compressed form."""
+    from langchain_core.runnables import RunnableLambda
+
+    sess = session or Session(resolver=resolver)
+
+    def _transform(value):
+        messages = value.to_messages() if hasattr(value, "to_messages") else list(value)
+        return _rewrite_tool_messages(sess, model, messages)
+
+    return RunnableLambda(_transform)
+
+
+def compress_pre_model_hook(session=None, model="gpt-4o", resolver=None):
+    """LangGraph pre_model_hook: compress accumulated tool outputs before each model call.
+
+    Tool results pile up in state and are re-sent every step. Returns them as `llm_input_messages` so
+    the model reads the compressed form while durable `messages` history keeps the originals
+    byte-for-byte. Returns no update when nothing compresses (or the rewrite fails)."""
+    sess = session or Session(resolver=resolver)
+
+    def _hook(state):
+        messages = state["messages"] if isinstance(state, dict) else getattr(state, "messages", [])
+        rewritten = _rewrite_tool_messages(sess, model, messages)
+        if rewritten is messages or all(a is b for a, b in zip(rewritten, messages)):
+            return {}
+        return {"llm_input_messages": rewritten}
+
+    return _hook

secondwind/litellm.py

@@ -0,0 +1,38 @@
+"""LiteLLM callback: add secondwind lossless compression with one line.
+
+    import litellm
+    from secondwind.litellm import SecondwindCallback
+    litellm.callbacks = [SecondwindCallback()]
+"""
+
+import logging
+
+try:
+    from litellm.integrations.custom_logger import CustomLogger as _CustomLogger
+except ImportError:  # litellm optional
+    _CustomLogger = object
+
+from . import Session
+
+logger = logging.getLogger("secondwind")
+
+
+class SecondwindCallback(_CustomLogger):
+    """One-line LiteLLM integration; compresses every request's tool outputs in-process, losslessly.
+    Any failure falls back to the original request."""
+
+    def __init__(self, resolver: str | None = None, home: str | None = None):
+        super().__init__()
+        self._session = Session(resolver=resolver, home=home)
+
+    async def async_pre_call_hook(self, user_api_key_dict, cache, data, call_type):
+        try:
+            out = self._session.rewrite(data)
+            if isinstance(out, dict) and "request" in out:
+                data.update(out["request"])
+        except Exception as exc:  # never break the call
+            logger.warning("secondwind compression skipped: %s", exc)
+        return data
+
+    def close(self):
+        self._session.close()

secondwind/strands.py

@@ -0,0 +1,48 @@
+"""Strands Agents integration: compress tool results losslessly as they are produced.
+
+    from strands import Agent
+    from secondwind.strands import SecondwindHooks
+
+    agent = Agent(model=..., tools=[...], hooks=[SecondwindHooks()])
+
+Registers on AfterToolCallEvent and rewrites each tool result's text before it reaches the model,
+in-process. Any failure leaves the result untouched.
+"""
+
+try:
+    from strands.hooks import AfterToolCallEvent, HookProvider
+
+    _STRANDS = True
+except ImportError:  # strands optional
+    HookProvider = object
+    _STRANDS = False
+
+from . import Session
+
+
+class SecondwindHooks(HookProvider):
+    def __init__(self, resolver=None):
+        self._session = Session(resolver=resolver)
+
+    def register_hooks(self, registry, **kwargs):
+        registry.add_callback(AfterToolCallEvent, self._on_after_tool_call)
+
+    def _on_after_tool_call(self, event):
+        try:
+            result = getattr(event, "result", None)
+            content = result.get("content") if isinstance(result, dict) else None
+            if not content:
+                return
+            tool_use_id = result.get("toolUseId", "t")
+            for block in content:
+                text = block.get("text") if isinstance(block, dict) else None
+                if not isinstance(text, str) or not text:
+                    continue
+                out = self._session.rewrite(
+                    {"model": "", "messages": [{"role": "tool", "tool_call_id": tool_use_id, "content": text}]}
+                )
+                new = out["request"]["messages"][0]["content"]
+                if isinstance(new, str) and new != text:
+                    block["text"] = new  # mutate the result dict in place, before it reaches the model
+        except Exception:  # never break the run
+            pass

secondwind-0.1.0.dist-info/METADATA

@@ -0,0 +1,68 @@
+Metadata-Version: 2.4
+Name: secondwind
+Version: 0.1.0
+Summary: Lossless, provable, composable LLM context compression
+License: Apache-2.0
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: litellm
+Requires-Dist: litellm; extra == "litellm"
+
+# secondwind
+
+Lossless, provable, composable LLM tool-output compression, in-process.
+
+```python
+import secondwind
+
+session = secondwind.Session()
+out = session.rewrite(request)          # compress a whole request's tool outputs
+print(out["stats"])                     # tokens saved
+secondwind.compress(block)              # or compress a single tool-output block
+
+# one-line LiteLLM integration:
+import litellm
+from secondwind.litellm import SecondwindCallback
+litellm.callbacks = [SecondwindCallback()]
+
+# ASGI gateway (Starlette / FastAPI): rewrite request bodies before you forward them upstream
+from secondwind.asgi import SecondwindMiddleware
+app.add_middleware(SecondwindMiddleware)
+
+# LangChain (LCEL): compress tool outputs before the model call
+from secondwind.langchain import compress_tool_outputs
+chain = compress_tool_outputs() | model
+
+# LangGraph: compress the tool outputs an agent loop re-sends before each model call
+from secondwind.langchain import compress_pre_model_hook
+agent = create_react_agent(model, tools, pre_model_hook=compress_pre_model_hook())
+
+# Agno: a lossless drop-in for its LLM-based tool-result compression
+from secondwind.agno import SecondwindCompressionManager
+agent = Agent(model=..., compress_tool_results=True,
+              compression_manager=SecondwindCompressionManager(compress_tool_results=True))
+
+# Strands Agents: compress tool results as they are produced
+from secondwind.strands import SecondwindHooks
+agent = Agent(model=..., tools=[...], hooks=[SecondwindHooks()])
+
+# Cursor: a postToolUse hook that rewrites MCP tool output the model sees
+#   ~/.cursor/hooks.json -> { "version": 1, "hooks": { "postToolUse": [ { "command": "python -m secondwind.cursor" } ] } }
+```
+
+```python
+# Bring your own codec: it competes in the best-of-N search, and secondwind proves
+# decode(encode(x)) == x for every block, so a wrong codec is dropped, never shipped.
+class MyCodec:
+    def encode(self, text): ...   # -> str | None
+    def decode(self, wire): ...   # -> str | None
+session = secondwind.Session(codec=MyCodec())     # reckless is safe: proven per-instance
+session = secondwind.Session(proposers=False)     # turn the aggressive search off
+
+# Offload big blocks and recover them on demand, or back the store with Redis / S3 / a database.
+session = secondwind.Session(resolver="resolve", offload_dir="~/.secondwind/offload")
+session = secondwind.Session(store=MyStore())     # any object with put(id, value) and get(id)
+```
+
+Every result is lossless and independently verifiable (`secondwind.verify(wire, hash)`); the native
+library is bundled, so there is no build step and no model download.

secondwind-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+secondwind/__init__.py,sha256=wicKKYZtwp47QiuGujJFSUJVealtTS0hqbxXvvtEgAs,8521
+secondwind/agno.py,sha256=HtSqdJAc5j889mFGx_W4ebSFae6JNYbDKIdmzcq11cE,1919
+secondwind/asgi.py,sha256=uKdOy3OQTBzs2f2TckVnvDAoSxhuEkaqK6FqJbwCkb8,3056
+secondwind/cursor.py,sha256=-dwAqpNsKCSzpJI7boh7Mug072KHgneG3SwACq8wC-Y,2357
+secondwind/langchain.py,sha256=XW1OCIJEGkSjQtxs9ttIs6bBbAK4e8TXZLfUfvd9qW4,3532
+secondwind/litellm.py,sha256=eo4-hEXVqHishstFRsRxwlPVld5iRnQAllqsN6ewEho,1283
+secondwind/strands.py,sha256=BIB4d8w0ZW7wWnDrVpB6HwMqKESqZ7usU8YSEe_W8t4,1858
+secondwind/_lib/secondwind.dll,sha256=Gm4EkJsWY8Ss9v5nDI1EuXxvsSqcpA6aJ9VTl-ubSZk,25816064
+secondwind-0.1.0.dist-info/METADATA,sha256=wcfxtAIHUIwF2G5m3AVYvD7YYFRPtweBRZ_E9vybNLE,2983
+secondwind-0.1.0.dist-info/WHEEL,sha256=hVx9elvUDfBjRmbl8JwIcXXikst35RZTZK9nspfI_28,98
+secondwind-0.1.0.dist-info/top_level.txt,sha256=5UNKECt3jgJKyrOzgZw9tb2VeJU-lz817ERGm-qNrAY,11
+secondwind-0.1.0.dist-info/RECORD,,

secondwind-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: false
+Tag: py3-none-win_amd64
+

secondwind-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+secondwind