tokenecon 0.1.0__py3-none-any.whl

tokenecon/__init__.py

@@ -0,0 +1,22 @@
+"""tokenecon: token-economics cost model and tiered routing for agentic AI."""
+
+from .classifier import difficulty_score
+from .cost_model import CallRecord, task_cost, tiering_ratio
+from .mock import MockModel
+from .pricing import DEFAULT_TIERS, ModelTier
+from .receipts import StepReceipt, TaskReceipt
+from .router import TieredRouter
+
+__version__ = "0.1.0"
+__all__ = [
+    "ModelTier",
+    "DEFAULT_TIERS",
+    "CallRecord",
+    "task_cost",
+    "tiering_ratio",
+    "difficulty_score",
+    "TieredRouter",
+    "StepReceipt",
+    "TaskReceipt",
+    "MockModel",
+]

tokenecon/classifier.py

@@ -0,0 +1,38 @@
+"""Heuristic request-difficulty scoring (paper, section 3.1).
+
+Deliberately simple and deliberately replaceable: scores surface signals —
+request length, analytical keywords, question marks, multi-step phrasing —
+into a 0..1 difficulty number. Teams should start here and graduate to a
+learned classifier once they have labeled traffic.
+"""
+
+from __future__ import annotations
+
+import re
+
+_ANALYTICAL_KEYWORDS = frozenset(
+    {
+        "compare", "contrast", "design", "prove", "proof", "analyze",
+        "analyse", "evaluation", "evaluate", "synthesize", "architect",
+        "derive", "derivation", "optimize", "trade-off", "tradeoff",
+    }
+)
+_MULTI_STEP_PATTERNS = (
+    r"\bstep by step\b",
+    r"\bfirst\b.*\bthen\b",
+    r"\bmulti-?step\b",
+)
+
+
+def difficulty_score(request: str) -> float:
+    """Score request difficulty in [0, 1] from surface signals."""
+    text = request.lower()
+    score = 0.15  # floor: every request costs attention
+    words = len(text.split())
+    score += min(words / 400.0, 0.25)
+    hits = sum(1 for kw in _ANALYTICAL_KEYWORDS if kw in text)
+    score += min(hits * 0.12, 0.36)
+    score += min(text.count("?") * 0.05, 0.10)
+    if any(re.search(p, text) for p in _MULTI_STEP_PATTERNS):
+        score += 0.15
+    return round(min(max(score, 0.0), 1.0), 3)

tokenecon/cli.py

@@ -0,0 +1,90 @@
+"""Command-line interface: demo the router, forecast spend, compare baselines."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+
+from .mock import MockModel
+from .pricing import DEFAULT_TIERS, ModelTier
+from .router import TieredRouter
+
+DEMO_TASKS = [
+    "What is the capital of France?",
+    "Summarize these three paragraphs about our Q3 cloud spend in two sentences.",
+    "Compare Kubernetes and ECS for our batch workload and recommend one, with trade-offs.",
+    "Debug this multi-step data pipeline failure. First reproduce the error, then trace it "
+    "through three services, then propose a fix.",
+    "Design a fault-tolerant agent orchestration layer. Prove it handles partial tool "
+    "failures. Show your reasoning step by step.",
+]
+
+
+def _tiers_from_json(path: str):
+    with open(path) as fh:
+        data = json.load(fh)
+    return [ModelTier(**t) for t in data["tiers"]]
+
+
+def cmd_demo(args: argparse.Namespace) -> int:
+    tiers = _tiers_from_json(args.tiers) if args.tiers else list(DEFAULT_TIERS)
+    router = TieredRouter(tiers=tiers, budget=args.budget)
+    model = MockModel()
+    total = 0.0
+    for task in DEMO_TASKS:
+        receipt = router.run(task, model)
+        total += receipt.total_cost
+        print(receipt.pretty())
+        print("-" * 60)
+    # Baseline: every task served by the strongest tier, one step each.
+    strongest = max(tiers, key=lambda t: t.capability)
+    baseline = sum(
+        strongest.call_cost(len(t) // 4 + 200, 340) for t in DEMO_TASKS
+    )
+    print(f"router total   : ${total:.6f}")
+    print(f"all-large total: ${baseline:.6f}")
+    print(f"ratio          : {total / baseline:.2%} of baseline")
+    return 0
+
+
+def cmd_estimate(args: argparse.Namespace) -> int:
+    tiers = _tiers_from_json(args.tiers) if args.tiers else list(DEFAULT_TIERS)
+    router = TieredRouter(tiers=tiers)
+    with open(args.requests) as fh:
+        requests = [line.strip() for line in fh if line.strip()]
+    total = 0.0
+    print(f"{'difficulty':>10} {'tier':>8} {'est_cost':>12}  request")
+    for req in requests:
+        f = router.forecast(req)
+        total += f["est_cost"]
+        print(f"{f['difficulty']:>10.3f} {f['tier']:>8} ${f['est_cost']:>10.6f}  {req[:60]}")
+    print(f"\nforecast total for {len(requests)} requests: ${total:.6f}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="tokenecon",
+        description="Token-economics cost model and tiered routing for agentic AI.",
+    )
+    p.add_argument("--tiers", help="JSON file with custom tier definitions")
+    sub = p.add_subparsers(dest="command", required=True)
+
+    d = sub.add_parser("demo", help="run 5 sample tasks through the router")
+    d.add_argument("--budget", type=float, default=None, help="per-task budget in USD")
+    d.set_defaults(func=cmd_demo)
+
+    e = sub.add_parser("estimate", help="forecast cost for a list of requests")
+    e.add_argument("requests", help="text file, one request per line")
+    e.set_defaults(func=cmd_estimate)
+    return p
+
+
+def main(argv=None) -> int:
+    args = build_parser().parse_args(argv)
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tokenecon/cost_model.py

@@ -0,0 +1,54 @@
+"""Per-task cost decomposition across the four token streams.
+
+Streams (paper, section 2.1): prompt tokens, completion tokens, tool-call
+overhead, and retrieval tokens. For a task making N calls::
+
+    C_task = sum_i( t_in_i * p_in_m(i) + t_out_i * p_out_m(i) )
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from .pricing import ModelTier
+
+
+@dataclass
+class CallRecord:
+    """One priced model call inside a task."""
+
+    tier: ModelTier
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    tool_tokens: int = 0
+    retrieval_tokens: int = 0
+
+    @property
+    def input_tokens(self) -> int:
+        return self.prompt_tokens + self.tool_tokens + self.retrieval_tokens
+
+    @property
+    def output_tokens(self) -> int:
+        return self.completion_tokens
+
+    def cost(self) -> float:
+        return self.tier.call_cost(self.input_tokens, self.output_tokens)
+
+
+def task_cost(calls: Iterable[CallRecord]) -> float:
+    """Total USD cost of a task from its per-call records."""
+    return sum(call.cost() for call in calls)
+
+
+def tiering_ratio(planning_fraction: float, price_ratio: float) -> float:
+    """C_tiered / C_all_strong ≈ α + (1 − α) / r (paper, section 2.3).
+
+    With planning fraction α ≈ 0.1 and price ratio r ≈ 30, tiered cost is
+    roughly 13% of the all-strong baseline.
+    """
+    if price_ratio <= 0:
+        raise ValueError("price_ratio must be positive")
+    if not 0.0 <= planning_fraction <= 1.0:
+        raise ValueError("planning_fraction must be in [0, 1]")
+    return planning_fraction + (1.0 - planning_fraction) / price_ratio

tokenecon/mock.py

@@ -0,0 +1,24 @@
+"""Deterministic mock model for demos and tests.
+
+Stands in for live provider calls so routing, escalation, receipts, and
+guardrails can be exercised with no API keys. Confidence is a deterministic
+function of tier capability vs. request difficulty — replace with a real
+signal (logprobs, verifier, sampling agreement) in production.
+"""
+
+from __future__ import annotations
+
+from typing import Tuple
+
+from .classifier import difficulty_score
+from .pricing import ModelTier
+
+
+class MockModel:
+    """model_fn(request, tier) -> (answer, confidence)."""
+
+    def __call__(self, request: str, tier: ModelTier) -> Tuple[str, float]:
+        difficulty = difficulty_score(request)
+        confidence = tier.capability - 0.25 * difficulty + 0.15
+        confidence = round(min(max(confidence, 0.0), 1.0), 3)
+        return f"[{tier.name}] answer to: {request[:60]}", confidence

tokenecon/pricing.py

@@ -0,0 +1,40 @@
+"""Model tier definitions and price handling.
+
+A tier is a priced capability band: input/output price per million tokens
+plus a capability score in [0, 1]. Prices here are ILLUSTRATIVE placeholders —
+substitute your provider's actual price list before making decisions.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Tuple
+
+
+@dataclass(frozen=True)
+class ModelTier:
+    name: str
+    input_per_mtok: float   # USD per million input tokens
+    output_per_mtok: float  # USD per million output tokens
+    capability: float       # 0..1, higher = more capable
+
+    def __post_init__(self) -> None:
+        if not 0.0 <= self.capability <= 1.0:
+            raise ValueError("capability must be in [0, 1]")
+        if self.input_per_mtok < 0 or self.output_per_mtok < 0:
+            raise ValueError("prices must be non-negative")
+
+    def call_cost(self, input_tokens: int, output_tokens: int) -> float:
+        """Cost in USD of one call with the given token counts."""
+        return (
+            input_tokens / 1_000_000 * self.input_per_mtok
+            + output_tokens / 1_000_000 * self.output_per_mtok
+        )
+
+
+#: Illustrative three-tier ladder (price ratio large/small = 30, as in the paper).
+DEFAULT_TIERS: Tuple[ModelTier, ...] = (
+    ModelTier("small", input_per_mtok=0.20, output_per_mtok=0.80, capability=0.35),
+    ModelTier("medium", input_per_mtok=1.00, output_per_mtok=4.00, capability=0.65),
+    ModelTier("large", input_per_mtok=6.00, output_per_mtok=24.00, capability=0.95),
+)

tokenecon/receipts.py

@@ -0,0 +1,59 @@
+"""Per-step and per-task cost receipts (paper, section 4.2).
+
+The receipt is the unit of cost observability: tier used, tokens, cost, and
+confidence per step, plus totals. Accumulated over time, receipts become the
+dataset from which the routing policy improves.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class StepReceipt:
+    tier: str
+    input_tokens: int
+    output_tokens: int
+    cost: float
+    confidence: float
+    note: str = ""
+
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class TaskReceipt:
+    request: str
+    difficulty: float
+    steps: List[StepReceipt] = field(default_factory=list)
+    answer: Optional[str] = None
+    total_cost: float = 0.0
+    outcome: str = "ok"  # ok | degraded | degraded_cached
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "request": self.request,
+            "difficulty": self.difficulty,
+            "outcome": self.outcome,
+            "total_cost": round(self.total_cost, 6),
+            "answer": self.answer,
+            "steps": [s.to_dict() for s in self.steps],
+        }
+
+    def pretty(self) -> str:
+        lines = [
+            f"request    : {self.request[:80]}",
+            f"difficulty : {self.difficulty}",
+            f"outcome    : {self.outcome}",
+        ]
+        for i, s in enumerate(self.steps, 1):
+            lines.append(
+                f"  step {i}: tier={s.tier} in={s.input_tokens} "
+                f"out={s.output_tokens} cost=${s.cost:.6f} "
+                f"conf={s.confidence:.2f} {s.note}".rstrip()
+            )
+        lines.append(f"total_cost : ${self.total_cost:.6f}")
+        return "\n".join(lines)

tokenecon/router.py

@@ -0,0 +1,146 @@
+"""Tiered routing: classify, select, escalate, budget, receipt (paper, section 3).
+
+Design summary
+--------------
+1. Score the request's difficulty (0..1).
+2. Select the cheapest tier whose capability clears difficulty + safety margin;
+   fall back to the strongest tier — the router never refuses work.
+3. Run the model; if confidence is below the quality threshold, escalate to
+   the next tier (cascade). Confidence may come from logprobs, a verifier, or
+   sampling agreement — the router only needs a number and a threshold.
+4. Guardrails (budgets degrade, never fail):
+   - Before spending: if even the cheapest first step exceeds the remaining
+     budget, serve a cached answer for $0 and mark the run degraded.
+   - Before escalating: if the next tier up would break the budget, keep the
+     current tier's answer and mark the run degraded.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Dict, List, Optional, Tuple
+
+from .classifier import difficulty_score
+from .pricing import ModelTier
+from .receipts import StepReceipt, TaskReceipt
+
+#: model_fn(request, tier) -> (answer, confidence in [0, 1])
+ModelFn = Callable[[str, ModelTier], Tuple[str, float]]
+
+_SYSTEM_PROMPT_TOKENS = 200  # rough allowance for system instructions
+
+
+@dataclass
+class TieredRouter:
+    tiers: List[ModelTier]
+    safety_margin: float = 0.10
+    quality_threshold: float = 0.70
+    budget: Optional[float] = None  # USD ceiling per task; None = unbounded
+
+    def __post_init__(self) -> None:
+        if len(self.tiers) < 2:
+            raise ValueError("need at least two tiers to route between")
+        # Ascending by price; capability is expected to rise with price.
+        self.tiers = sorted(self.tiers, key=lambda t: (t.input_per_mtok, t.capability))
+        self._cache: Dict[str, str] = {}
+
+    # -- policy ---------------------------------------------------------
+
+    def select_tier(self, difficulty: float) -> ModelTier:
+        """Cheapest tier whose capability clears difficulty + margin."""
+        bar = min(difficulty + self.safety_margin, 1.0)
+        for tier in self.tiers:
+            if tier.capability >= bar:
+                return tier
+        return self.tiers[-1]
+
+    def _next_tier(self, tier: ModelTier) -> Optional[ModelTier]:
+        idx = self.tiers.index(tier)
+        return self.tiers[idx + 1] if idx + 1 < len(self.tiers) else None
+
+    # -- token estimation (heuristic; ~4 chars/token for English) --------
+
+    def _estimate_io(self, request: str, tier: ModelTier, step: int) -> Tuple[int, int]:
+        base_in = len(request) // 4 + _SYSTEM_PROMPT_TOKENS
+        # Context accumulates across steps: each prior step appends its
+        # output plus retrieval-ish overhead (paper, section 2.1).
+        input_tokens = base_in + step * 700
+        output_tokens = {"small": 120, "medium": 220}.get(tier.name, 340)
+        return input_tokens, output_tokens
+
+    # -- run ------------------------------------------------------------
+
+    def run(self, request: str, model_fn: ModelFn) -> TaskReceipt:
+        difficulty = difficulty_score(request)
+        receipt = TaskReceipt(request=request, difficulty=difficulty)
+        spent = 0.0
+
+        # Guardrail 1 — before spending: cheapest first step over budget
+        # and a cached answer exists -> serve it for $0, degraded.
+        cheapest = self.tiers[0]
+        in_tok, out_tok = self._estimate_io(request, cheapest, 0)
+        if (
+            self.budget is not None
+            and cheapest.call_cost(in_tok, out_tok) > self.budget
+            and request in self._cache
+        ):
+            receipt.answer = self._cache[request]
+            receipt.outcome = "degraded_cached"
+            receipt.steps.append(
+                StepReceipt(
+                    tier="cache", input_tokens=0, output_tokens=0,
+                    cost=0.0, confidence=1.0,
+                    note="budget exhausted; served cached answer",
+                )
+            )
+            return receipt
+
+        tier = self.select_tier(difficulty)
+        answer: Optional[str] = None
+        step = 0
+        while True:
+            in_tok, out_tok = self._estimate_io(request, tier, step)
+            step_cost = tier.call_cost(in_tok, out_tok)
+            answer, confidence = model_fn(request, tier)
+            spent += step_cost
+            receipt.steps.append(
+                StepReceipt(
+                    tier=tier.name, input_tokens=in_tok,
+                    output_tokens=out_tok, cost=step_cost,
+                    confidence=round(confidence, 3),
+                )
+            )
+            if confidence >= self.quality_threshold:
+                break
+            nxt = self._next_tier(tier)
+            if nxt is None:
+                break
+            # Guardrail 2 — before escalating: next tier would break the
+            # budget -> keep this answer, mark degraded.
+            n_in, n_out = self._estimate_io(request, nxt, step + 1)
+            if self.budget is not None and spent + nxt.call_cost(n_in, n_out) > self.budget:
+                receipt.outcome = "degraded"
+                receipt.steps[-1].note = "escalation skipped: budget"
+                break
+            tier, step = nxt, step + 1
+
+        receipt.answer = answer
+        receipt.total_cost = spent
+        if receipt.outcome == "ok":
+            self._cache[request] = answer or ""
+        return receipt
+
+    # -- forecasting (no model calls) ------------------------------------
+
+    def forecast(self, request: str) -> Dict[str, float]:
+        """Predicted tier and cost for a request without running any model."""
+        difficulty = difficulty_score(request)
+        tier = self.select_tier(difficulty)
+        in_tok, out_tok = self._estimate_io(request, tier, 0)
+        return {
+            "difficulty": difficulty,
+            "tier": tier.name,
+            "input_tokens": in_tok,
+            "output_tokens": out_tok,
+            "est_cost": tier.call_cost(in_tok, out_tok),
+        }

tokenecon-0.1.0.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: tokenecon
+Version: 0.1.0
+Summary: Token-economics cost model and tiered model routing for agentic AI workloads
+Author: Karmendra Pandey
+License: MIT
+Project-URL: Homepage, https://github.com/karmendra8386/agentic-ai-token-economics
+Project-URL: Paper, https://zenodo.org/records/23195511
+Keywords: llm,agents,cost,routing,token-economics,inference
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# tokenecon — Token-Economics for Agentic AI
+
+A dependency-free Python implementation of the token-economics cost model and
+tiered model routing design from the paper
+[*Token-Economics for Agentic AI: A Cost Model and Tiered Routing Reference*](https://zenodo.org/records/23195511)
+(K. Pandey, Oct 2026).
+
+**The problem it solves:** a single model call has a predictable price; a looping
+agent does not. Every tool call, observation, retry, and retrieved document adds
+another round-trip through a priced model, and teams usually discover the total
+from the cloud bill instead of the architecture. This package gives you two things:
+
+1. **A cost model** — decompose per-task spend into prompt, completion, tool-call,
+   and retrieval tokens, priced per model tier, so you can forecast and budget
+   before deployment instead of reconciling after it.
+2. **A tiered router** — classify each request by difficulty, send it to the
+   cheapest tier capable of handling it, escalate on low confidence, and enforce
+   per-task budgets that degrade gracefully instead of failing.
+
+## Install
+
+```bash
+pip install tokenecon
+```
+
+No dependencies. Python 3.9+.
+
+From source: `git clone https://github.com/karmendra8386/agentic-ai-token-economics.git && cd agentic-ai-token-economics && pip install .`
+
+## Quickstart
+
+```python
+from tokenecon import TieredRouter, DEFAULT_TIERS, MockModel
+
+router = TieredRouter(tiers=list(DEFAULT_TIERS), budget=0.05)  # 5¢ per task
+receipt = router.run("Summarize our Q3 cloud spend in two sentences.", MockModel())
+print(receipt.pretty())
+# request    : Summarize our Q3 cloud spend in two sentences.
+# difficulty : 0.213
+# outcome    : ok
+#   step 1: tier=small in=210 out=120 cost=$0.000138 conf=0.70
+# total_cost : $0.000138
+```
+
+Every run produces a **receipt**: tier used, tokens, cost, and confidence per step.
+Receipts are the unit of cost observability — accumulate them and they become the
+dataset your routing policy improves from.
+
+## CLI
+
+```bash
+# Run 5 sample tasks through the router and compare against the all-large baseline
+tokenecon demo
+
+# Same, under a 1¢ per-task budget (watch guardrails kick in)
+tokenecon demo --budget 0.01
+
+# Forecast spend for a list of requests (one per line, no model calls)
+tokenecon estimate requests.txt
+
+# Bring your own tiers (JSON: {"tiers": [{"name": ..., "input_per_mtok": ...,
+#   "output_per_mtok": ..., "capability": ...}]})
+tokenecon demo --tiers my-tiers.json
+```
+
+## How the router works
+
+1. **Classify** — each request gets a difficulty score (0–1) from surface signals:
+   length, analytical keywords ("compare", "design", "prove"), question marks,
+   multi-step phrasing. Simple and replaceable; graduate to a learned classifier
+   with labeled traffic.
+2. **Select** — cheapest tier whose capability clears difficulty + safety margin.
+   Falls back to the strongest tier; the router never refuses work.
+3. **Escalate** — every response carries a confidence signal; below the quality
+   threshold, the request cascades to the next tier (try cheap, escalate on doubt).
+4. **Budget** — two guardrails, both degrade instead of failing:
+   - *Before spending:* if the cheapest first step exceeds the budget, serve a
+     cached answer for $0.
+   - *Before escalating:* if the next tier up would break the budget, keep the
+     current answer and mark the run degraded.
+
+The tiering arithmetic: with planning fraction α ≈ 0.1 and price ratio r ≈ 30
+between tiers, tiered cost is roughly 13% of the all-strong baseline —
+`tokenecon.tiering_ratio(0.1, 30)`.
+
+## Honest limitations
+
+- **Pricing is illustrative.** Default tiers are placeholders. Substitute your
+  provider's actual price list before making decisions.
+- **Token counting is heuristic** (~4 chars/token for English). Production use
+  needs the provider's tokenizer or usage API.
+- **Confidence comes from the mock model** in demos. Production needs a real
+  signal: log-probabilities, a verifier model, or sampling agreement.
+- **Single-request scope.** Multi-turn compounding (tool-call overhead, retrieval
+  accumulation) is modeled in the cost equations but not executed by the router.
+- See the paper (§6) for the full limitations discussion.
+
+## Cite
+
+If you use this in your work, please cite the paper:
+
+> K. Pandey, "Token-Economics for Agentic AI: A Cost Model and Tiered Routing
+> Reference," Zenodo, DOI [10.5281/zenodo.23195511](https://zenodo.org/records/23195511), Oct. 2026.
+
+A `CITATION.cff` is included for automated citation tooling.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

tokenecon-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+tokenecon/__init__.py,sha256=yxOKUokNwOnnY2j6FD-FV3Svll0U_GnIh4of_PTvHdQ,566
+tokenecon/classifier.py,sha256=pxoA2iva9nCuotJUNIz-5jpVcgu-1krbEe-gFPSyPZ0,1299
+tokenecon/cli.py,sha256=tV8Q-QnJo7K9TjSrs9InbGVHkr9wgzlS60KSIAvUqJQ,3225
+tokenecon/cost_model.py,sha256=-iZ6kQ3r876XfXacN2OnXNuKL4QWHmzK7-3zElAe6kg,1638
+tokenecon/mock.py,sha256=TH76LRc8zpWrR85QJuAcDqPXLp9zevL4SGBrtGJXBW8,873
+tokenecon/pricing.py,sha256=zZue3DoZcEzJTfSuUc7wDjVuLzHDHXBhk8AF7TQ2cT8,1547
+tokenecon/receipts.py,sha256=Zi09mfJpg3brrCgYaD0Jm_fh0wvliFx4sgmI1iKy0C4,1761
+tokenecon/router.py,sha256=C685V3zg0vBvEutTfE-zEMR3L3fnyLz8DEHsqWvhJCc,6037
+tokenecon-0.1.0.dist-info/licenses/LICENSE,sha256=nlBEbSdzFQm0N1c7RgWKfW89WAZCcF39W6zQakVvdyE,1073
+tokenecon-0.1.0.dist-info/METADATA,sha256=1qwic-p4DQwg9m7efYXIIqimcLZ-_wmjXOJGCT32808,5267
+tokenecon-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+tokenecon-0.1.0.dist-info/entry_points.txt,sha256=jzy0_iVyWKmMDcodi1arMrEUUShjvdBsOb_8s7yT8-8,49
+tokenecon-0.1.0.dist-info/top_level.txt,sha256=BqPju2pDQEbcM72iU3XRTFreHuDDJC7wLFjKFdlEuCw,10
+tokenecon-0.1.0.dist-info/RECORD,,

tokenecon-0.1.0.dist-info/WHEEL

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

tokenecon-0.1.0.dist-info/entry_points.txt

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

tokenecon-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Karmendra Pandey
+
+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.

tokenecon-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+tokenecon