earcon 0.1.0__py3-none-any.whl

earcon/__init__.py

@@ -0,0 +1,10 @@
+"""Earcon: a self-evolving memory proxy for OpenAI-compatible clients.
+
+Any LLM application gets experience-driven learning by changing one
+baseURL. Model weights stay frozen; experience is accumulated,
+adjudicated, and injected as context. See docs/how-it-works.md.
+
+Based on the mechanisms of JitRL (arXiv:2601.18510).
+"""
+
+__version__ = "0.1.0"

earcon/cli.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+"""CLI: `earcon serve` starts the learning proxy.
+
+Examples:
+    earcon serve --upstream https://api.openai.com/v1 --api-key $KEY \
+        --judge-model gpt-4o-mini --port 8800
+
+    # pure observation (no injection) while you assess judge quality:
+    earcon serve --upstream ... --no-inject
+"""
+
+import argparse
+import json
+import os
+
+
+def build_parser():
+    p = argparse.ArgumentParser(prog="earcon", description=__doc__)
+    sub = p.add_subparsers(dest="cmd")
+    serve = sub.add_parser("serve", help="run the learning proxy gateway")
+    serve.add_argument("--upstream", required=True,
+                       help="OpenAI-compatible upstream base URL, e.g. "
+                            "https://api.openai.com/v1 "
+                            "(env: EARCON_UPSTREAM)")
+    serve.add_argument("--api-key", default=os.environ.get("EARCON_API_KEY", ""),
+                       help="key used for upstream calls; clients' own keys "
+                            "are ignored (env: EARCON_API_KEY)")
+    serve.add_argument("--port", type=int, default=8800)
+    serve.add_argument("--db", default="earcon_memory.db")
+    serve.add_argument("--judge-model", required=True,
+                       help="model used for credit assignment")
+    serve.add_argument("--no-inject", action="store_true",
+                       help="record-only mode: judge sessions, never inject")
+    serve.add_argument("--judge-extra-body", default=None,
+                       help="JSON object merged into judge requests, for "
+                            "vendor-private params (e.g. disabling a "
+                            "reasoning mode). Never sent to the main path.")
+    serve.add_argument("--session-timeout", type=float, default=1800,
+                       help="seconds of inactivity before a session is "
+                            "closed and judged (default 1800)")
+    serve.add_argument("--inject-top-k", type=int, default=5)
+    return p
+
+
+def main(argv=None):
+    p = build_parser()
+    args = p.parse_args(argv)
+    if args.cmd != "serve":
+        p.print_help()
+        return 2
+
+    extra = json.loads(args.judge_extra_body) if args.judge_extra_body else None
+
+    # local imports so the core library never requires fastapi
+    from earcon.gateway import Gateway, create_app
+    gw = Gateway(upstream=args.upstream, api_key=args.api_key,
+                 db_path=args.db, judge_model=args.judge_model,
+                 inject=not args.no_inject, extra_body=extra,
+                 config={"session_timeout": args.session_timeout,
+                         "inject_top_k": args.inject_top_k})
+    app = create_app(gw)
+
+    import uvicorn
+    print("earcon gateway: http://127.0.0.1:%d  ->  %s" % (args.port, args.upstream))
+    print("memory: %s | mode: %s" % (args.db,
+                                     "record+inject" if gw.inject else "record-only"))
+    uvicorn.run(app, host="127.0.0.1", port=args.port, log_level="warning")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

earcon/core/__init__.py

@@ -0,0 +1,5 @@
+"""Core library: memory, advantage estimation, policies, judges, backends.
+
+Pure logic, zero third-party dependencies (the OpenAI-compatible backend
+lazily imports `openai` only when used).
+"""

earcon/core/advantage.py

@@ -0,0 +1,51 @@
+# -*- coding: utf-8 -*-
+"""Advantage estimation: V(s), Q(s,a), A = Q - V, UCB exploration, shrinkage.
+
+Corresponds to step 3 of JitRL:
+  V   = mean return over the neighborhood        ("how good is this situation")
+  Q   = mean return of the cards that took action a
+  A   = Q - V                                    ("how much better than average")
+  unseen actions: UCB-style optimism with probability lam, else 0
+
+Two engineering corrections the paper leaves implicit:
+
+- small-sample shrinkage: A = (Q - V) * n / (n + m). An action with 1-2
+  cards has a noisy Q; max-normalization amplified that noise into a
+  full-scale advantage (we observed "bump into a wall" being learned as
+  the best action). Shrinkage lets thin evidence speak softly.
+- clip to [-1, 1] instead of max-normalizing: normalization re-amplifies
+  relative noise when all advantages are small, cancelling shrinkage.
+"""
+
+import random
+
+
+class AdvantageEstimator:
+    def __init__(self, lam=0.05, alpha=2.0, min_neighbors=3, shrink=4.0, seed=0):
+        self.lam = lam          # exploration probability
+        self.alpha = alpha      # UCB bonus strength
+        self.min_neighbors = min_neighbors
+        self.shrink = shrink
+        self.rng = random.Random(seed)
+
+    def estimate(self, neighbors, actions):
+        """neighbors: [(action, G, sim), ...]; actions: full action list.
+        Returns {action: A} clipped to [-1, 1]."""
+        n = len(neighbors)
+        if n < self.min_neighbors:
+            return {a: 0.0 for a in actions}
+
+        V = sum(G for _, G, _ in neighbors) / n
+        adv = {}
+        for a in actions:
+            Gs = [G for act, G, _ in neighbors if act == a]
+            if Gs:
+                Q = sum(Gs) / len(Gs)
+                adv[a] = (Q - V) * len(Gs) / (len(Gs) + self.shrink)
+            else:
+                if self.rng.random() < self.lam:
+                    adv[a] = self.alpha / n
+                else:
+                    adv[a] = 0.0
+
+        return {a: max(-1.0, min(1.0, v)) for a, v in adv.items()}

earcon/core/backends.py

@@ -0,0 +1,148 @@
+# -*- coding: utf-8 -*-
+"""Model backends: produce per-option "impulse values" (logit or pseudo-logit).
+
+- MockBackend: zero-dependency stand-in with human-like biases, for demos
+  and tests. It has direction preferences, reacts to objects in sight
+  (including distractions), and has no cross-episode memory - exactly the
+  flaws a frozen base model exhibits in a new environment.
+- OpenAICompatBackend: real logits via logprobs (the paper's token-level
+  path; requires an OpenAI-compatible endpoint that supports logprobs,
+  e.g. a self-hosted vLLM). Needs the `openai` package.
+- VerbalConfidenceBackend: black-box fallback for restricted gateways
+  (no logprobs): one call asking the model to rate each option 0-100,
+  ln(p) as a pseudo-logit. The paper's black-box path. Any vendor-
+  private parameters (e.g. disabling a reasoning mode) go through
+  `extra_body` and are never sent by default.
+"""
+
+import json
+import math
+import re
+
+
+class MockBackend:
+    PREFS = {
+        "north": 1.2, "east": 1.0, "south": 0.2, "west": 0.0,
+        "pick key": -0.5, "take treasure": -0.5, "smash jar": -0.5,
+    }
+    REFLEX = {
+        "a key on the ground": {"pick key": 2.2},
+        "you have the key": {"take treasure": 2.2},
+        "a chest stands here": {"take treasure": 0.3},
+        "a jar sits in the corner": {"smash jar": 0.8},
+    }
+
+    def __init__(self, seed=0, noise=1.0):
+        import random
+        self.rng = random.Random(seed)
+        self.noise = noise
+
+    def choice_logits(self, prompt, options):
+        """options: [(letter, text), ...] -> {letter: logit}"""
+        reflex = {}
+        low = prompt.lower()
+        for marker, boosts in self.REFLEX.items():
+            if marker in low:
+                for k, v in boosts.items():
+                    reflex[k] = reflex.get(k, 0.0) + v
+        return {
+            letter: (self.PREFS.get(text, 0.0) + reflex.get(text, 0.0)
+                     + self.rng.gauss(0, self.noise))
+            for letter, text in options
+        }
+
+
+class OpenAICompatBackend:
+    def __init__(self, base_url, api_key, model, timeout=60, retries=2):
+        from openai import OpenAI  # lazy: core lib stays zero-dependency
+        self.client = OpenAI(base_url=base_url, api_key=api_key or "EMPTY",
+                             timeout=timeout, max_retries=retries)
+        self.model = model
+
+    def choice_logits(self, prompt, options):
+        lines = [prompt, "", "Options:"]
+        for letter, text in options:
+            lines.append("%s. %s" % (letter, text))
+        lines.append("Answer with a single letter, nothing else.")
+        resp = self.client.chat.completions.create(
+            model=self.model,
+            messages=[{"role": "user", "content": "\n".join(lines)}],
+            max_tokens=1, temperature=0.0,
+            logprobs=True, top_logprobs=20)
+        top = resp.choices[0].logprobs.content[0].top_logprobs
+        logits = {}
+        for letter, _ in options:
+            hit = [t.logprob for t in top if t.token.strip().upper() == letter]
+            if hit:
+                logits[letter] = max(hit)
+        if not logits:
+            return {letter: 0.0 for letter, _ in options}
+        floor = min(logits.values()) - 5.0
+        return {letter: logits.get(letter, floor) for letter, _ in options}
+
+    def chat(self, messages, max_tokens=1024):
+        resp = self.client.chat.completions.create(
+            model=self.model, messages=messages, max_tokens=max_tokens)
+        return resp.choices[0].message.content
+
+
+class VerbalConfidenceBackend:
+    """Black-box path: one scoring call, JSON output, ln(p) pseudo-logits."""
+
+    def __init__(self, base_url, api_key, model, timeout=60, retries=2,
+                 extra_body=None):
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self.model = model
+        self.timeout = timeout
+        self.retries = retries
+        self.extra_body = dict(extra_body or {})
+
+    def _post(self, payload):
+        import urllib.request
+        req = urllib.request.Request(
+            self.base_url + "/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json",
+                     "Authorization": "Bearer " + (self.api_key or "")})
+        with urllib.request.urlopen(req, timeout=self.timeout) as r:
+            return json.loads(r.read().decode("utf-8"))
+
+    def _chat(self, text, max_tokens):
+        payload = {"model": self.model,
+                   "messages": [{"role": "user", "content": text}],
+                   "max_tokens": max_tokens, "stream": False}
+        payload.update(self.extra_body)
+        d = self._post(payload)
+        return d["choices"][0]["message"].get("content") or ""
+
+    def choice_logits(self, prompt, options):
+        lines = [prompt, "", "Options:"]
+        for letter, text in options:
+            lines.append("%s. %s" % (letter, text))
+        lines.append("Rate each option 0-100 (higher = more you want to do it)."
+                     " Output one line of JSON only, e.g. %s"
+                     % json.dumps({l: 50 for l, _ in options}))
+        scores = None
+        for _ in range(self.retries + 1):
+            try:
+                text = self._chat("\n".join(lines), max_tokens=3000)
+                m = re.search(r"\{[^{}]*\}", text, re.S)
+                scores = json.loads(m.group(0))
+                break
+            except Exception:
+                continue
+        if not isinstance(scores, dict):
+            return {letter: 0.0 for letter, _ in options}
+        logits = {}
+        for letter, _ in options:
+            try:
+                s = float(scores.get(letter, 1))
+            except (TypeError, ValueError):
+                s = 1.0
+            logits[letter] = math.log(max(s, 0.5) / 100.0)
+        return logits
+
+    def chat(self, messages, max_tokens=4096):
+        text = "\n\n".join(m["content"] for m in messages)
+        return self._chat(text, max_tokens=max_tokens)

earcon/core/judge.py

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+"""Judges: credit assignment at episode boundaries, then discounted returns.
+
+- ReturnJudge: uses the environment's real per-step rewards (verifiable
+  rewards - tests passing, tickets resolved). Default and recommended.
+- LLMJudge: the paper's approach - a model scores each step of the
+  trajectory. Quality of the judge bounds the whole system, so failures
+  fall back to the verifiable path.
+"""
+
+import re
+
+JUDGE_PROMPT = """You are scoring one episode of an agent's trajectory (outcome: {outcome}).
+Rate each step's contribution to the final outcome on a scale of -3 to +3
+(positive = helped, negative = hurt). Output exactly {n} integer scores,
+one per line, nothing else.
+
+{steps}"""
+
+
+class ReturnJudge:
+    """G_t = sum_u gamma^(u-t) * r_u, but normalized by the remaining
+    horizon so that early steps in long episodes are not silently
+    discounted into irrelevance. A plain discounted return makes G at
+    t=0 of a 25-step failure ~-0.15 vs -1.0 at the end; the early
+    trap-fall card then looks fine and memory never learns to avoid it.
+    G_t = (raw discounted return) / (gamma^(T-t) scale), i.e. the
+    average-quality-of-remaining-future interpretation."""
+
+    def __init__(self, gamma=0.9):
+        self.gamma = gamma
+
+    def score(self, trajectory, success):
+        """trajectory: [(state, action, r), ...] -> [(state, action, G), ...]"""
+        T = len(trajectory)
+        raw = []
+        for t in range(T):
+            G = sum((self.gamma ** (u - t)) * trajectory[u][2]
+                    for u in range(t, T))
+            raw.append(G / (1 - self.gamma) if self.gamma < 1.0 else G)
+        out = [(s, a, g) for (s, a, _), g in zip(trajectory, raw)]
+        return out
+
+
+class LLMJudge:
+    def __init__(self, backend, gamma=0.9, scale=3.0):
+        self.backend = backend
+        self.fallback = ReturnJudge(gamma)
+        self.scale = scale
+
+    def score(self, trajectory, success):
+        steps = "\n".join(
+            "%d. [%s] -> %s" % (i + 1, s, a)
+            for i, (s, a, _) in enumerate(trajectory))
+        prompt = JUDGE_PROMPT.format(
+            outcome="success" if success else "failure",
+            n=len(trajectory), steps=steps)
+        try:
+            text = self.backend.chat([{"role": "user", "content": prompt}])
+            nums = [int(x) for x in re.findall(r"-?\d+", text)]
+            if len(nums) < len(trajectory):
+                raise ValueError("not enough scores")
+            shaped = [(s, a, n / float(self.scale))
+                      for (s, a, _), n in zip(trajectory, nums)]
+            return self.fallback.score(shaped, success)
+        except Exception:
+            return self.fallback.score(trajectory, success)

earcon/core/memory.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+"""Experience memory: (state, action, return) cards in SQLite, Jaccard retrieval.
+
+Non-parametric memory in the JitRL sense. Structured-text + Jaccard was
+empirically better than embeddings in our experiments (and needs no
+vector infra), so retrieval is deliberately simple. Two corrections the
+paper leaves implicit are built in:
+
+- recency pool: experience is non-stationary; recent cards must win ties
+  against early failures (otherwise learning curves can stall and even
+  regress as stale cards keep occupying the neighborhood);
+- single-token coordinates: naive tokenization can treat "r0c1" and
+  "r1c0" as the same token set, silently conflating distinct states.
+  Callers should compose position-like attributes into one token.
+"""
+
+import re
+import sqlite3
+import time
+
+_TOKEN_RE = re.compile(r"[A-Za-z0-9]+|[一-鿿]")
+
+
+def tokenize(text):
+    """Latin/digits by word, CJK by character; returns a set for Jaccard."""
+    return set(_TOKEN_RE.findall(text or ""))
+
+
+def jaccard(a, b):
+    if not a or not b:
+        return 0.0
+    inter = len(a & b)
+    return inter / float(len(a) + len(b) - inter)
+
+
+class MemoryStore:
+    def __init__(self, db_path="earcon_memory.db", max_cards=5000,
+                 recency_pool=2000):
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self.lock = __import__("threading").Lock()
+        self.max_cards = max_cards
+        self.recency_pool = recency_pool
+        self.conn.execute(
+            """CREATE TABLE IF NOT EXISTS cards(
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   namespace TEXT,
+                   state TEXT,
+                   action TEXT,
+                   G REAL,
+                   created REAL)""")
+        self.conn.commit()
+
+    def add(self, namespace, state, action, G):
+        with self.lock:
+            self.conn.execute(
+                "INSERT INTO cards(namespace, state, action, G, created) "
+                "VALUES(?,?,?,?,?)",
+                (namespace, state, action, G, time.time()))
+            self.conn.commit()
+            n = self.conn.execute("SELECT COUNT(*) FROM cards").fetchone()[0]
+            if n > self.max_cards:
+                self.conn.execute(
+                    "DELETE FROM cards WHERE id IN "
+                    "(SELECT id FROM cards ORDER BY id LIMIT ?)",
+                    (n - self.max_cards,))
+                self.conn.commit()
+
+    def retrieve(self, namespace, state, k=10, min_sim=0.9):
+        """Most-similar k cards as [(action, G, sim), ...].
+
+        min_sim defaults high (near-exact match) for discrete-state tasks;
+        lower it for fuzzier domains. Ties prefer newer cards.
+        """
+        rows = self.conn.execute(
+            "SELECT state, action, G FROM cards WHERE namespace=? "
+            "ORDER BY id DESC LIMIT ?",
+            (namespace, self.recency_pool)).fetchall()
+        if not rows:
+            return []
+        q = tokenize(state)
+        scored = [(action, G, jaccard(q, tokenize(s))) for s, action, G in rows]
+        scored = [x for x in scored if x[2] >= min_sim]
+        scored.sort(key=lambda x: -x[2])
+        return scored[:k]
+
+    def size(self, namespace=None):
+        if namespace is None:
+            return self.conn.execute("SELECT COUNT(*) FROM cards").fetchone()[0]
+        return self.conn.execute(
+            "SELECT COUNT(*) FROM cards WHERE namespace=?",
+            (namespace,)).fetchone()[0]
+
+    def close(self):
+        self.conn.close()

earcon/core/policy.py

@@ -0,0 +1,62 @@
+# -*- coding: utf-8 -*-
+"""Policy: z' = z + beta * A, the closed-form update of KL-constrained
+policy improvement. Works over any backend that produces per-option
+"impulse values" (logits or pseudo-logits).
+
+use_memory=False degrades to the pure base policy (the control arm).
+"""
+
+import math
+import random
+
+
+class JitRLPolicy:
+    def __init__(self, backend, memory, estimator, beta=3.0,
+                 use_memory=True, greedy=False, seed=0):
+        self.backend = backend
+        self.memory = memory
+        self.estimator = estimator
+        self.beta = beta
+        self.use_memory = use_memory
+        self.greedy = greedy
+        self.rng = random.Random(seed)
+
+    def act(self, prompt, state, namespace, actions):
+        """Returns (chosen action, debug info). actions: list of texts."""
+        options = [(chr(ord("A") + i), a) for i, a in enumerate(actions)]
+        z = self.backend.choice_logits(prompt, options)
+
+        adv = {a: 0.0 for a in actions}
+        n_neighbors = 0
+        if self.use_memory:
+            neighbors = self.memory.retrieve(namespace, state)
+            n_neighbors = len(neighbors)
+            adv = self.estimator.estimate(neighbors, actions)
+
+        adjusted = {
+            letter: z[letter] + self.beta * adv[text]
+            for letter, text in options
+        }
+
+        best = (max(adjusted, key=adjusted.get) if self.greedy
+                else self._softmax_sample(adjusted))
+
+        debug = {
+            "neighbors": n_neighbors,
+            "logits": {t: round(z[l], 2) for l, t in options},
+            "advantage": {t: round(adv[t], 2) for _, t in options},
+            "chosen": options[ord(best) - ord("A")][1],
+        }
+        return debug["chosen"], debug
+
+    def _softmax_sample(self, logits):
+        m = max(logits.values())
+        exps = {k: math.exp(v - m) for k, v in logits.items()}
+        total = sum(exps.values())
+        r = self.rng.random() * total
+        acc = 0.0
+        for k, v in exps.items():
+            acc += v
+            if r <= acc:
+                return k
+        return list(logits)[-1]

earcon/gateway/__init__.py

@@ -0,0 +1,316 @@
+# -*- coding: utf-8 -*-
+"""The earcon gateway: a transparent OpenAI-compatible proxy that learns.
+
+Request path (every turn):
+    client -> [experience injection] -> transparent forward -> upstream
+    response streams back while the turn is recorded into a session buffer.
+
+Learning path (session close, background thread):
+    an LLM judge distills the trajectory into experience cards ->
+    SQLite memory -> retrieved for future sessions' injections.
+
+For free-text coding/chat sessions (no enumerable action space) the
+JitRL logit adjustment is realized as context injection instead: it is
+the same loop (experience -> behavior change) at the fidelity the
+protocol allows. The core library (earcon.core) implements the discrete
+logit path used by examples/treasure_maze.
+"""
+
+import json
+import re
+import sqlite3
+import threading
+import time
+import urllib.request
+
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse, StreamingResponse
+
+DEFAULTS = {
+    "session_timeout": 1800.0,   # seconds of inactivity -> session close
+    "sweep_interval": 60.0,      # how often the reaper checks for timeouts
+    "max_turns_judged": 40,
+    "min_turns_to_judge": 3,
+    "task_sig_chars": 120,       # task signature length for retrieval
+    "inject_top_k": 5,           # cards per injection
+    "inject_threshold": 0.15,    # |G| beyond which a card is useful/a lesson
+    "retrieve_scan_limit": 3000, # recent-card scan window
+    "retrieve_min_overlap": 2,   # keyword overlap to count as related
+    "turn_user_chars": 2000,
+    "turn_assistant_chars": 4000,
+}
+
+JUDGE_PROMPT = """Below is the full trajectory of a coding-assistant session
+(user request -> assistant key response). Distill 1-5 reusable experience
+cards from the assistant's performance. One card per line, format:
+decision=<a key decision the assistant got right or wrong, max 30 words> ; score=<integer -3..3, positive if right, negative if wrong>
+Output only those lines.
+
+{steps}"""
+
+
+class GatewayMemory:
+    def __init__(self, db_path):
+        self.conn = sqlite3.connect(db_path, check_same_thread=False)
+        self.lock = threading.Lock()
+        self.conn.execute(
+            """CREATE TABLE IF NOT EXISTS cards(
+                   id INTEGER PRIMARY KEY AUTOINCREMENT,
+                   task TEXT,
+                   action TEXT,
+                   G REAL,
+                   created REAL)""")
+        self.conn.commit()
+
+    def add(self, task, action, G):
+        with self.lock:
+            self.conn.execute(
+                "INSERT INTO cards(task, action, G, created) VALUES(?,?,?,?)",
+                (task, action, G, time.time()))
+            self.conn.commit()
+
+    def size(self):
+        return self.conn.execute("SELECT COUNT(*) FROM cards").fetchone()[0]
+
+    def retrieve_top(self, task_sig, scan_limit, min_overlap, k):
+        rows = self.conn.execute(
+            "SELECT task, action, G FROM cards ORDER BY id DESC LIMIT ?",
+            (scan_limit,)).fetchall()
+        if not rows:
+            return []
+        q = set(re.findall(r"[\w一-鿿]+", (task_sig or "").lower()))
+        scored = []
+        for task, action, G in rows:
+            t = set(re.findall(r"[\w一-鿿]+", (task or "").lower()))
+            inter = len(q & t)
+            if inter >= min_overlap:
+                scored.append((inter, G, action))
+        scored.sort(key=lambda x: (-x[0], -x[1]))
+        return scored[:k]
+
+
+class Gateway:
+    def __init__(self, upstream, api_key, db_path, judge_model,
+                 inject=True, extra_body=None, config=None):
+        self.upstream = upstream.rstrip("/")
+        self.api_key = api_key
+        self.judge_model = judge_model
+        self.inject = inject
+        self.extra_body = dict(extra_body or {})
+        self.conf = dict(DEFAULTS)
+        self.conf.update(config or {})
+        self.mem = GatewayMemory(db_path)
+
+        self.sessions = {}            # sid -> {"turns": [...], "last": ts}
+        self.session_lock = threading.Lock()
+        self._stop = threading.Event()
+        self.reaper = threading.Thread(target=self._reap_loop, daemon=True)
+        self.reaper.start()
+
+    # ---------------- session bookkeeping ----------------
+
+    def record_turn(self, sid, user_text, assistant_text):
+        c = self.conf
+        with self.session_lock:
+            s = self.sessions.setdefault(sid, {"turns": [], "last": time.time()})
+            s["turns"].append((user_text[:c["turn_user_chars"]],
+                               (assistant_text or "")[:c["turn_assistant_chars"]]))
+            s["last"] = time.time()
+
+    def close_session(self, sid):
+        with self.session_lock:
+            s = self.sessions.pop(sid, None)
+        if s and len(s["turns"]) >= self.conf["min_turns_to_judge"]:
+            threading.Thread(target=self._judge_and_write,
+                             args=(s["turns"],), daemon=True).start()
+        return len((s or {}).get("turns", []))
+
+    def _reap_loop(self):
+        while not self._stop.wait(self.conf["sweep_interval"]):
+            now = time.time()
+            stale = []
+            with self.session_lock:
+                for sid, s in list(self.sessions.items()):
+                    if now - s["last"] > self.conf["session_timeout"]:
+                        stale.append(sid)
+            for sid in stale:
+                self.close_session(sid)
+
+    # ---------------- judging ----------------
+
+    def _judge_and_write(self, turns):
+        try:
+            sig = self._task_signature(turns)
+            if not sig:
+                return
+            c = self.conf
+            lines = ["%d. user: %s" % (i + 1, u[:600])
+                     for i, (u, a) in enumerate(turns[:c["max_turns_judged"]])]
+            steps = "\n".join(
+                "%d. user: %s\n   assistant: %s"
+                % (i + 1, u[:600], a[:600])
+                for i, (u, a) in enumerate(turns[:c["max_turns_judged"]]))
+            text = self._llm_chat(JUDGE_PROMPT.format(steps=steps))
+            for line in text.splitlines():
+                m = re.search(r"decision=(.+?)\s*;\s*score=(-?\d+)", line)
+                if m:
+                    self.mem.add(sig, m.group(1).strip(),
+                                 int(m.group(2)) / 3.0)
+        except Exception as e:
+            print("[earcon] judge error:", e)
+
+    def _task_signature(self, turns):
+        for u, _ in turns:
+            if u.strip():
+                return u[:self.conf["task_sig_chars"]]
+        return ""
+
+    def _llm_chat(self, prompt, max_tokens=2000):
+        payload = {"model": self.judge_model,
+                   "messages": [{"role": "user", "content": prompt}],
+                   "max_tokens": max_tokens, "stream": False,
+                   "temperature": 0.0}
+        payload.update(self.extra_body)
+        req = urllib.request.Request(
+            self.upstream + "/chat/completions",
+            data=json.dumps(payload).encode("utf-8"),
+            headers={"Content-Type": "application/json",
+                     "Authorization": "Bearer " + (self.api_key or "")})
+        with urllib.request.urlopen(req, timeout=120) as r:
+            d = json.loads(r.read().decode("utf-8"))
+        return d["choices"][0]["message"].get("content") or ""
+
+    # ---------------- injection ----------------
+
+    def experience_prefix(self, task_sig):
+        c = self.conf
+        top = self.mem.retrieve_top(task_sig, c["retrieve_scan_limit"],
+                                    c["retrieve_min_overlap"], c["inject_top_k"])
+        if not top:
+            return None
+        lines = ["[earcon experience] lessons from past similar sessions:"]
+        for _, G, action in top:
+            tag = ("worked" if G > c["inject_threshold"]
+                   else "failed" if G < -c["inject_threshold"] else "mixed")
+            lines.append("- (%s) %s" % (tag, action))
+        lines.append("Treat these as historical summaries; use your own "
+                     "judgment for the current task.")
+        return "\n".join(lines)
+
+    # ---------------- HTTP ----------------
+
+    def _forward(self, body):
+        req = urllib.request.Request(
+            self.upstream + "/chat/completions",
+            data=json.dumps(body).encode("utf-8"),
+            headers={"Content-Type": "application/json",
+                     "Authorization": "Bearer " + (self.api_key or "")})
+        return urllib.request.urlopen(req, timeout=300)
+
+    def handle_chat(self, body, auth_key):
+        messages = body.get("messages", [])
+
+        # session id: honor explicit metadata, else one request per session
+        # is naturally grouped by close_session/timeout sweeps
+        sid = (body.get("metadata") or {}).get("session_id") or "default"
+
+        if self.inject and messages:
+            sig = (_first_user_text(messages) or "")[:self.conf["task_sig_chars"]]
+            if sig.strip():
+                prefix = self.experience_prefix(sig)
+                if prefix:
+                    new_msgs, inserted = [], False
+                    for m in messages:
+                        new_msgs.append(m)
+                        if not inserted and m.get("role") == "system":
+                            new_msgs.append({"role": "system", "content": prefix})
+                            inserted = True
+                    if not inserted:
+                        new_msgs.insert(0, {"role": "system", "content": prefix})
+                    body = dict(body)
+                    body["messages"] = new_msgs
+
+        upstream_key = self.api_key or auth_key
+        stream = body.get("stream", False)
+        body_json = json.dumps(body).encode("utf-8")
+        headers = {"Content-Type": "application/json",
+                   "Authorization": "Bearer " + upstream_key}
+        req = urllib.request.Request(self.upstream + "/chat/completions",
+                                     data=body_json, headers=headers)
+        up_resp = urllib.request.urlopen(req, timeout=300)
+
+        if stream:
+            def gen():
+                collected = []
+                try:
+                    for chunk in up_resp:
+                        yield chunk
+                        try:
+                            line = chunk.decode("utf-8").strip()
+                            if line.startswith("data: ") and line != "data: [DONE]":
+                                j = json.loads(line[6:])
+                                delta = (j.get("choices") or [{}])[0].get("delta", {})
+                                if delta.get("content"):
+                                    collected.append(delta["content"])
+                        except Exception:
+                            pass
+                finally:
+                    if collected:
+                        self.record_turn(sid, _first_user_text(messages) or "",
+                                         "".join(collected))
+
+            return StreamingResponse(gen(), media_type="text/event-stream")
+        else:
+            d = json.loads(up_resp.read().decode("utf-8"))
+            content = (d["choices"][0]["message"].get("content") or "")
+            self.record_turn(sid, _first_user_text(messages) or "", content)
+            return d
+
+
+def _first_user_text(messages):
+    for m in messages:
+        if m.get("role") == "user":
+            c = m.get("content")
+            if isinstance(c, str):
+                return c
+            if isinstance(c, list):
+                for part in c:
+                    if isinstance(part, dict) and part.get("type") == "text":
+                        return part.get("text", "")
+    return ""
+
+
+def create_app(gateway):
+    app = FastAPI()
+
+    @app.post("/v1/chat/completions")
+    @app.post("/chat/completions")
+    async def proxy_chat(request: Request):
+        body = await request.json()
+        auth_key = request.headers.get("Authorization", "").replace("Bearer ", "")
+        result = gateway.handle_chat(body, auth_key)
+        if isinstance(result, StreamingResponse):
+            return result
+        return JSONResponse(result)
+
+    @app.get("/v1/models")
+    @app.get("/models")
+    async def models():
+        req = urllib.request.Request(
+            gateway.upstream + "/models",
+            headers={"Authorization": "Bearer " + (gateway.api_key or "")})
+        with urllib.request.urlopen(req, timeout=30) as r:
+            return JSONResponse(json.loads(r.read().decode("utf-8")))
+
+    @app.get("/v1/earcon/stats")
+    async def stats():
+        return JSONResponse({"cards": gateway.mem.size(),
+                             "sessions_open": len(gateway.sessions),
+                             "inject": gateway.inject})
+
+    @app.post("/v1/earcon/session/{sid}/close")
+    async def close_session(sid: str):
+        n = gateway.close_session(sid)
+        return JSONResponse({"closed": sid, "turns": n})
+
+    return app

earcon-0.1.0.dist-info/METADATA

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: earcon
+Version: 0.1.0
+Summary: A self-evolving memory proxy for OpenAI-compatible clients: any LLM app gets experience-driven learning by changing one baseURL.
+License: Apache-2.0
+Keywords: llm,agents,memory,self-improvement,jitrl,proxy,reinforcement-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: gateway
+Requires-Dist: fastapi>=0.100; extra == "gateway"
+Requires-Dist: uvicorn>=0.23; extra == "gateway"
+Provides-Extra: openai
+Requires-Dist: openai>=1.0; extra == "openai"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# earcon
+
+**A self-evolving memory proxy for OpenAI-compatible clients.**
+Point your app's `base_url` at earcon, keep working normally - the model
+starts learning from every session, with **zero weight updates** and
+**zero client changes beyond one URL**.
+
+- **What it is**: a local proxy that records your LLM sessions, has a
+  judge distill them into experience cards (a decision + a score), and
+  injects the relevant experience into future similar sessions.
+- **What it is not**: not fine-tuning, not another RAG memory of user
+  facts. It stores *behavioral* experience with returns - "this approach
+  worked, that one failed" - and changes decisions, not just knowledge.
+- **Lineage**: mechanisms from [JitRL: Just-In-Time Reinforcement
+  Learning](https://arxiv.org/abs/2601.18510) (ICML 2026 Spotlight):
+  non-parametric experience memory, advantage estimation, and
+  experience-driven action reweighting - realized for free-text agents.
+
+```
+your app (any OpenAI SDK / LangGraph / coding client ...)
+        │  change one base_url
+        ▼
+   earcon gateway ──① inject experience──▶ upstream LLM (frozen weights)
+        │ ② record every turn
+        ▼
+   ③ judge on session close ──▶ ④ SQLite experience cards ──▶ back to ①
+```
+
+![architecture](docs/architecture.png)
+
+## Why not just mem0 / Letta / Zep?
+
+Those store *facts* ("the user prefers concise answers") and retrieve
+them into context. earcon stores **scored behavior** and follows the
+JitRL loop:
+
+| | fact memories (mem0 et al.) | earcon |
+|---|---|---|
+| Stored unit | "user likes X" | "decision D on task T scored -3" |
+| Signal | none (storage only) | return / judge credit assignment |
+| Changes decisions? | indirectly, via recall | directly - experience is *retrieved by task similarity and weighted by outcome* |
+| Auditable | depends | one SQLite file, every card inspectable |
+| Intrusive | SDK / API changes | one `base_url` swap |
+
+## Quickstart
+
+```bash
+# legacy pip (<22) mishandles pyproject-only git installs (UNKNOWN-0.0.0):
+python3 -m pip install --upgrade pip
+
+# from GitHub (PyPI coming soon):
+python3 -m pip install "git+https://github.com/370540009gg-cmd/earcon.git"
+# extras: "earcon[gateway,openai]" via pip, or install fastapi/uvicorn yourself
+
+# terminal 1: run the gateway against any OpenAI-compatible upstream
+earcon serve --upstream https://api.openai.com/v1 \
+    --api-key $OPENAI_API_KEY --judge-model gpt-4o-mini
+
+# terminal 2: any OpenAI app, one line changed
+#   OpenAI(base_url="http://127.0.0.1:8800/v1", ...)
+python examples/quickstart_client.py
+```
+
+Work normally. Sessions close (30 min idle, or explicit
+`POST /v1/earcon/session/default/close`), the judge distills cards,
+and future similar requests arrive pre-loaded with your own track
+record:
+
+```bash
+curl http://127.0.0.1:8800/v1/earcon/stats
+# {"cards": 14, "sessions_open": 1, "inject": true}
+
+sqlite3 earcon_memory.db "SELECT task, action, G FROM cards LIMIT 5"
+```
+
+**Start in observation mode** while you assess your judge's card
+quality: `earcon serve ... --no-inject`. The judge is the quality
+ceiling of the whole system.
+
+## Does it actually work?
+
+The discrete-action path is verified in `examples/treasure_maze/` - a
+toy environment where traps sit on the intuitive routes, so avoiding
+them is *only* knowable through experience:
+
+```bash
+# control arm (frozen behavior):      ~2% win, 4.0 trap falls / episode
+python examples/treasure_maze/run.py --episodes 150 --seed 2 --no-memory
+
+# earcon learning arm:                 ~43% win (up to 100% in late windows),
+python examples/treasure_maze/run.py --episodes 150 --seed 2
+#                                      1.0 falls/episode, 10.5 steps vs 6 optimal
+```
+
+The learned advantage at the trap-adjacent cells comes out correctly
+signed - memory, not luck. See `docs/how-it-works.md` for the full
+loop, and the honest list of conditions under which it *won't* work.
+
+## How it works
+
+1. **Record** - every turn flows through the gateway transparently
+   (streaming included) into a session buffer.
+2. **Judge** - on session close, a background judge call distills 1-5
+   experience cards ("decision=...; score -3..+3").
+3. **Retrieve & inject** - the next session's first user message is
+   matched against past cards; the top matches join the system prompt.
+
+For **enumerable action spaces** (agents, tools), `earcon.core`
+implements the paper's full path: per-option logits from `logprobs`,
+advantage `A = Q - V` with small-sample shrinkage, and the closed-form
+update `z' = z + βA`. The maze example runs it end to end.
+
+Details and design corrections: `docs/how-it-works.md` · client
+integration guide: `docs/client-integration.md`.
+
+## Configuration
+
+`earcon serve --upstream URL --judge-model M [--api-key K]
+[--db FILE] [--port 8800] [--no-inject] [--session-timeout 1800]
+[--inject-top-k 5] [--judge-extra-body '{"thinking":{"type":"off"}}']`
+
+- Credentials: `EARCON_API_KEY` env var or `--api-key`. The gateway
+  rewrites client keys with its own, so clients need no real key.
+- Vendor-private judge parameters (e.g. disabling a reasoning mode for
+  the scoring call) go through `--judge-extra-body`; nothing
+  non-standard is sent by default.
+
+## Honest limitations
+
+- **The judge is the ceiling.** A shallow judge produces noisy cards;
+  start with `--no-inject` and audit them.
+- **Injection, not logits, on the main path** - most hosted gateways
+  don't expose `logprobs`, so free-text learning happens through
+  context. The full logit path needs a `logprobs`-capable upstream
+  (vLLM etc.) and lives in `earcon.core`.
+- **Cold start requires a working base.** If the model never succeeds,
+  there are no positive cards to reinforce (JitRL has the same
+  constraint). Rough sweet spot: base success in the 20-60% band.
+- **Single-user, single-process.** No multi-tenant isolation; memory is
+  one SQLite file. The session reaper is a background thread, not a
+  distributed system.
+- **Task matching is keyword-based.** Deliberately (it beat embeddings
+  in our maze experiments and needs no infra), but it's simple.
+
+## Roadmap
+
+- [ ] Hermes agent `MemoryProvider` adapter
+- [ ] Server-side logit bias via vLLM `logit_bias` (true step-level steering)
+- [ ] Card editor / curation CLI
+- [ ] Multi-namespace memory (per-project, per-tenant)
+
+## License
+
+Apache-2.0. Built on the mechanisms of [JitRL](https://arxiv.org/abs/2601.18510)
+(Barrett et al.) - if you use earcon in research, please cite the paper.

earcon-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+earcon/__init__.py,sha256=6FZ4KvyfOneLXshTWONLo6I00_bCe8795tobL9bplBw,348
+earcon/cli.py,sha256=HUCXlIrL7qRFl3rp15_WKOWrkCuTYGEC2TMQuK1j6No,3029
+earcon/core/__init__.py,sha256=69wlQJzcIsuYfoXg1ZuRH4Q6fvWX52G09KSsOugpnSI,194
+earcon/core/advantage.py,sha256=uJGzRHClnqO4x7vZ85XVkye2tisnvTOVFLMCOrurMP4,2031
+earcon/core/backends.py,sha256=1kYi2PycBJkhX-GDFLjuYsMJKiUYcZIkj9pidh5tcB0,5997
+earcon/core/judge.py,sha256=VgrQIfQGujS4AXAvMRKXTnoujOpcb4QG6kw9ISIVq4M,2721
+earcon/core/memory.py,sha256=GZ89jz0ex9_rWkYdYWmqw3Tf-ISd8Z3oxvuJ7phVcCg,3507
+earcon/core/policy.py,sha256=xkfoK6J3AOHw4e0DuigVTpixTsdBWg8kTJbLgOwLOhY,2090
+earcon/gateway/__init__.py,sha256=2-laMa--kdi8X4g0EM8PDQ1N1JJaf_m1LKJ3VhmW5fA,12809
+earcon-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+earcon-0.1.0.dist-info/METADATA,sha256=FvZqL5TwATGlXjdKTqDYTCU_2pPy9A7kFCNvViyioWI,7615
+earcon-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+earcon-0.1.0.dist-info/entry_points.txt,sha256=WEDXC35pHLWkZEVy50_SS3i-b6AaaPMvbwCdJbqcc7o,43
+earcon-0.1.0.dist-info/top_level.txt,sha256=HmdG_LkVgOhEbCm2Uh5K6TIrDn1606aWRxDfGz4YVAo,7
+earcon-0.1.0.dist-info/RECORD,,

earcon-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

earcon-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+earcon = earcon.cli:main

earcon-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

earcon-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+earcon