programasweights 0.1.0.dev6__py3-none-any.whl → 0.1.0.dev8__py3-none-any.whl

programasweights/__init__.py

@@ -1,25 +1,28 @@
 """
-ProgramAsWeights (PAW): Compile natural language specs into neural programs.
+ProgramAsWeights (PAW): Compile natural language specs into tiny neural
+functions that run locally.
 
 Quick start:
     import programasweights as paw
 
-    # Compile on the server
-    program = paw.compile("Classify sentiment as positive or negative")
+    # Use a pre-compiled function (downloads once, runs locally forever)
+    fn = paw.function("email-triage")
+    fn("Urgent: server is down!")  # "immediate"
 
-    # Run locally via llama.cpp (downloads base model on first use)
+    # Compile your own from a description
+    program = paw.compile("Fix malformed JSON: repair missing quotes and trailing commas")
     fn = paw.function(program.id)
-    fn("I love this!")  # -> "positive"
+    fn("{name: 'Alice',}")  # '{"name": "Alice"}'
 
 API reference:
     paw.compile(spec)          Compile a spec on the server, returns Program
     paw.function(program_id)   Load a compiled program for local inference
-    paw.login(email)           Authenticate and store API key
+    paw.login()                Save API key for higher rate limits
     paw.api_url                Server URL (default: https://programasweights.com)
     paw.api_key                API key (set via login() or PAW_API_KEY env var)
 """
 
-__version__ = "0.1.0.dev6"
+__version__ = "0.1.0.dev8"
 
 from .config import get_api_url, get_api_key, set_api_key
 
@@ -34,41 +37,44 @@ def compile(
     name: str | None = None,
     tags: list[str] | None = None,
     public: bool = True,
+    slug: str | None = None,
 ):
     """Compile a natural language specification into a neural program.
 
     The compilation runs on the PAW server. The resulting program can be
-    downloaded and run locally via ``paw.function(program.id)``.
+    downloaded and run locally via ``paw.function(program.id)`` or
+    ``paw.function(program.slug)`` if a slug was provided.
 
     Args:
         spec: Full specification text. Include examples in the text if desired.
         compiler: Compiler model (alias or snapshot name).
-        name: Human-readable program name for the hub.
+        name: Human-readable program name (display title for the hub).
         tags: Tags for hub discovery.
         public: Whether to list on the public hub.
+        slug: URL-safe handle (e.g. 'message-classifier'). Creates a
+            ``username/slug`` alias. Requires authentication.
 
     Returns:
-        A ``Program`` object with ``id``, ``status``, and ``timings``.
+        A ``Program`` object with ``id``, ``slug``, ``status``, and ``timings``.
 
     Example:
         >>> program = paw.compile(
-        ...     "Classify sentiment as positive or negative.\\n"
-        ...     "Examples:\\n"
-        ...     "Input: I love it\\nOutput: positive\\n"
-        ...     "Input: I hate it\\nOutput: negative"
+        ...     "Fix malformed JSON: repair missing quotes and trailing commas",
+        ...     slug="json-fixer"
         ... )
-        >>> print(program.id)
-        '4a533a4fb0a10f219384'
+        >>> fn = paw.function(program.slug)  # or paw.function(program.id)
+        >>> fn("{name: 'Alice',}")
+        '{"name": "Alice"}'
     """
     from .client import PAWClient
     client = PAWClient(api_url=api_url, api_key=api_key)
-    return client.compile(spec, compiler=compiler, name=name, tags=tags, public=public)
+    return client.compile(spec, compiler=compiler, name=name, tags=tags, public=public, slug=slug)
 
 
 def function(
     program_id: str,
     n_ctx: int = 2048,
-    n_gpu_layers: int = -1,
+    n_gpu_layers: int | None = None,
     verbose: bool = False,
 ):
     """Load a compiled program for local inference via llama.cpp.
@@ -79,26 +85,36 @@ def function(
     Args:
         program_id: The program ID from ``paw.compile()``.
         n_ctx: Context window size for llama.cpp.
-        n_gpu_layers: GPU layers (-1 = all, 0 = CPU only).
+        n_gpu_layers: GPU layers (-1 = all, 0 = CPU only). Defaults to CPU.
+            Set ``PAW_GPU_LAYERS`` env var or pass explicitly for GPU acceleration.
         verbose: Print llama.cpp debug output.
 
     Returns:
         A callable ``PawFunction`` that takes an input string and returns output.
 
     Example:
-        >>> fn = paw.function("4a533a4fb0a10f219384")
-        >>> fn("I love this product!")
-        'positive'
+        >>> fn = paw.function("email-triage")
+        >>> fn("Urgent: the server is down!")
+        'immediate'
     """
+    import os
     import re
-    from .cache import is_program_cached, get_program_dir
+    from .cache import is_program_cached, get_program_dir, get_cached_slug, save_slug_mapping
     from .runtime_llamacpp import PawFunction
 
+    if n_gpu_layers is None:
+        n_gpu_layers = int(os.environ.get("PAW_GPU_LAYERS", "0"))
+
     resolved_id = program_id
     if not re.fullmatch(r"[a-f0-9]{16,64}", program_id):
-        from .client import PAWClient
-        client = PAWClient(api_url=api_url, api_key=api_key)
-        resolved_id = client.resolve_slug(program_id)
+        cached = get_cached_slug(program_id)
+        if cached:
+            resolved_id = cached
+        else:
+            from .client import PAWClient
+            client = PAWClient(api_url=api_url, api_key=api_key)
+            resolved_id = client.resolve_slug(program_id)
+            save_slug_mapping(program_id, resolved_id)
 
     if not is_program_cached(resolved_id):
         from .client import PAWClient
@@ -111,58 +127,52 @@ def function(
     )
 
 
-def login(email: str | None = None):
-    """Authenticate with the PAW server and store the API key locally.
+def login(key: str | None = None):
+    """Store an API key for authenticating with the PAW server.
 
-    If email is provided, sends a verification code to that email.
-    Prompts for the 6-digit code, then stores the API key in
-    ``~/.config/programasweights/config.json``.
+    If no key is provided, opens the Settings page in a browser
+    and prompts interactively for the key.
+
+    Generate your API key at https://programasweights.com/settings
 
     Args:
-        email: Email address. If None, prompts interactively.
+        key: API key string (``paw_sk_...``). If None, prompts interactively.
 
     Example:
-        >>> paw.login("user@example.com")
-        Verification code sent to user@example.com
-        Enter code: 123456
-        Authenticated! API key stored.
-    """
-    import httpx
+        >>> paw.login()
+        Generate an API key at https://programasweights.com/settings
+        Paste your API key: ********
+        API key saved.
 
-    if email is None:
-        email = input("Email: ").strip()
-
-    url = api_url.rstrip("/")
+        >>> paw.login("paw_sk_abc123...")
+        API key saved.
+    """
+    if key is None:
+        settings_url = api_url.rstrip("/") + "/settings"
+        print(f"Generate an API key at {settings_url}")
+        try:
+            import webbrowser
+            webbrowser.open(settings_url)
+        except Exception:
+            pass
 
-    # Request verification code
-    resp = httpx.post(
-        f"{url}/api/v1/auth/email",
-        json={"email": email},
-        timeout=10.0,
-    )
-    resp.raise_for_status()
-    print(f"Verification code sent to {email}")
+        import getpass
+        key = getpass.getpass("Paste your API key: ").strip()
 
-    # Prompt for code
-    code = input("Enter code: ").strip()
+    if not key:
+        print("No key provided. Aborted.")
+        return
 
-    # Verify and get API key
-    resp = httpx.post(
-        f"{url}/api/v1/auth/verify",
-        json={"email": email, "code": code},
-        timeout=10.0,
-    )
-    resp.raise_for_status()
-    data = resp.json()
+    if not key.startswith("paw_sk_"):
+        print("Warning: key doesn't start with 'paw_sk_'. Saving anyway.")
 
-    key = data.get("api_key", "")
     set_api_key(key)
 
     global api_key
     api_key = key
 
-    print(f"Authenticated! API key stored in ~/.config/programasweights/config.json")
-    print(f"Tier: {data.get('tier', 'unknown')}")
+    print("API key saved to ~/.config/programasweights/config.json")
+    print("You can also set the PAW_API_KEY environment variable.")
 
 
 __all__ = [

programasweights/cache.py

@@ -10,10 +10,12 @@ Cache structure:
                 adapter.gguf            # ~23 MB, Q4_0 LoRA
                 prompt_template.txt
                 meta.json
+        slug_cache.json                 # slug -> program_id mapping
 """
 
 from __future__ import annotations
 
+import json
 import os
 from pathlib import Path
 
@@ -22,11 +24,13 @@ import httpx
 from . import config
 
 BASE_MODEL_URLS = {
-    "qwen3-0.6b-q6_k": "https://huggingface.co/yuntian-deng/Qwen3-0.6B-GGUF-Q6_K/resolve/main/qwen3-0.6b-q6_k.gguf",
+    "qwen3-0.6b-q6_k": "https://huggingface.co/programasweights/Qwen3-0.6B-GGUF-Q6_K/resolve/main/qwen3-0.6b-q6_k.gguf",
+    "gpt2-q6_k": "https://huggingface.co/programasweights/GPT2-GGUF-Q6_K/resolve/main/gpt2-q6_k.gguf",
 }
 
 INTERPRETER_TO_GGUF = {
     "Qwen/Qwen3-0.6B": "qwen3-0.6b-q6_k",
+    "gpt2": "gpt2-q6_k",
 }
 
 
@@ -78,3 +82,36 @@ def _download_file(url: str, dest: Path):
                     mb = downloaded / 1024 / 1024
                     print(f"\r  {mb:.1f} MB ({pct:.0f}%)", end="", flush=True)
         print()
+
+
+def _slug_cache_path() -> Path:
+    return config.get_cache_dir() / "slug_cache.json"
+
+
+def get_cached_slug(slug: str) -> str | None:
+    """Look up a slug in the local cache. Returns program_id or None."""
+    path = _slug_cache_path()
+    if not path.exists():
+        return None
+    try:
+        data = json.loads(path.read_text())
+        program_id = data.get(slug)
+        if program_id and is_program_cached(program_id):
+            return program_id
+    except (json.JSONDecodeError, OSError):
+        pass
+    return None
+
+
+def save_slug_mapping(slug: str, program_id: str) -> None:
+    """Save a slug -> program_id mapping to the local cache."""
+    path = _slug_cache_path()
+    data: dict = {}
+    if path.exists():
+        try:
+            data = json.loads(path.read_text())
+        except (json.JSONDecodeError, OSError):
+            pass
+    data[slug] = program_id
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data))

programasweights/cli.py

@@ -7,9 +7,12 @@ Usage:
     paw run <program_id> <input>   Run a program locally
     paw login                      Authenticate with email
     paw info <program_id>          Show program metadata
+
+All commands support --json for structured output (agent-friendly).
 """
 
 import argparse
+import json
 import sys
 
 
@@ -20,23 +23,38 @@ def cmd_compile(args):
     if args.api_key:
         paw.api_key = args.api_key
 
-    print(f"Compiling: {args.spec[:80]}...")
-    program = paw.compile(args.spec, compiler=args.compiler)
+    if not args.json:
+        print(f"Compiling: {args.spec[:80]}...")
+
+    program = paw.compile(args.spec, compiler=args.compiler, slug=getattr(args, 'slug', None))
+
+    if args.json:
+        print(json.dumps({
+            "program_id": program.id,
+            "slug": program.slug,
+            "status": program.status,
+            "error": program.error,
+            "timings": program.timings,
+        }))
+        return 1 if program.error else 0
 
     if program.error:
         print(f"Error: {program.error}")
         return 1
 
     print(f"Program ID: {program.id}")
+    if program.slug:
+        print(f"Slug: {program.slug}")
     print(f"Status: {program.status}")
     if program.timings:
         total = program.timings.get("total_ms", 0)
         print(f"Total time: {total:.0f}ms")
+    ref = program.slug or program.id
     print(f"\nTo run locally:")
-    print(f"  paw run {program.id} \"your input here\"")
+    print(f"  paw run --program \"{ref}\" --input \"your input here\"")
     print(f"\nOr in Python:")
     print(f"  import programasweights as paw")
-    print(f"  fn = paw.function(\"{program.id}\")")
+    print(f"  fn = paw.function(\"{ref}\")")
     print(f"  fn(\"your input here\")")
     return 0
 
@@ -46,9 +64,15 @@ def cmd_run(args):
     if args.api_url:
         paw.api_url = args.api_url
 
-    fn = paw.function(args.program_id, verbose=args.verbose)
+    fn = paw.function(
+        args.program, verbose=args.verbose,
+    )
     result = fn(args.input, max_tokens=args.max_tokens, temperature=args.temperature)
-    print(result)
+
+    if args.json:
+        print(json.dumps({"program": args.program, "input": args.input, "output": result}))
+    else:
+        print(result)
     return 0
 
 
@@ -56,7 +80,38 @@ def cmd_login(args):
     import programasweights as paw
     if args.api_url:
         paw.api_url = args.api_url
-    paw.login(args.email)
+    paw.login(args.key)
+    return 0
+
+
+def cmd_rename(args):
+    import programasweights as paw
+    if args.api_url:
+        paw.api_url = args.api_url
+    if args.api_key:
+        paw.api_key = args.api_key
+
+    import httpx
+    from programasweights.client import PAWClient
+    client = PAWClient(api_url=paw.api_url, api_key=paw.api_key)
+
+    resp = httpx.patch(
+        f"{client._api_url}/api/v1/programs/{args.program}",
+        json={"slug": args.new_slug},
+        headers=client._headers(),
+        timeout=10.0,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    if args.json:
+        print(json.dumps(data))
+    else:
+        slug = data.get("slug")
+        if slug:
+            print(f"Renamed to: {slug}")
+        else:
+            print("Slug removed.")
     return 0
 
 
@@ -65,23 +120,32 @@ def cmd_info(args):
     if args.api_url:
         paw.api_url = args.api_url
 
-    from programasweights.cache import is_program_cached, get_program_dir
-    import json
+    from programasweights.client import PAWClient
+    client = PAWClient(api_url=paw.api_url, api_key=paw.api_key)
+
+    try:
+        meta = client.get_program_meta(args.program)
+    except Exception:
+        meta = None
 
-    if is_program_cached(args.program_id):
-        d = get_program_dir(args.program_id)
-        meta_path = d / "meta.json"
-        if meta_path.exists():
-            meta = json.loads(meta_path.read_text())
-            print(f"Program: {args.program_id}")
-            print(f"  Spec: {meta.get('spec', 'N/A')[:100]}")
+    if meta and meta.get("id"):
+        if args.json:
+            print(json.dumps(meta))
+        else:
+            print(f"Program: {meta.get('id')}")
+            print(f"  Spec: {(meta.get('spec') or 'N/A')[:100]}")
             print(f"  Interpreter: {meta.get('interpreter', 'N/A')}")
             print(f"  Compiler: {meta.get('compiler_snapshot', 'N/A')}")
-            print(f"  LoRA rank: {meta.get('lora_rank', 'N/A')}")
-            print(f"  Created: {meta.get('created_at', 'N/A')}")
-            return 0
+            print(f"  Aliases: {', '.join(meta.get('aliases', []))}")
+            print(f"  Downloads: {meta.get('downloads', 0)}")
+            if meta.get('hf_url'):
+                print(f"  HF URL: {meta['hf_url']}")
+        return 0
 
-    print(f"Program {args.program_id} not cached locally.")
+    if args.json:
+        print(json.dumps({"error": "not_found", "program": args.program}))
+    else:
+        print(f"Program {args.program} not found.")
     return 1
 
 
@@ -92,29 +156,36 @@ def main():
     )
     parser.add_argument("--api-url", default=None, help="PAW server URL")
     parser.add_argument("--api-key", default=None, help="API key")
+    parser.add_argument("--json", action="store_true",
+                        help="Output structured JSON (agent-friendly)")
 
     sub = parser.add_subparsers(dest="command")
 
-    # paw compile
     p = sub.add_parser("compile", help="Compile a spec on the server")
-    p.add_argument("spec", help="Natural language specification")
+    p.add_argument("--spec", required=True, help="Natural language specification")
     p.add_argument("--compiler", default="paw-4b-qwen3-0.6b", help="Compiler model")
+    p.add_argument("--slug", default=None, help="URL-safe handle (e.g. 'message-classifier')")
+    p.add_argument("--json", action="store_true", help="JSON output")
 
-    # paw run
     p = sub.add_parser("run", help="Run a program locally via llama.cpp")
-    p.add_argument("program_id", help="Program ID")
-    p.add_argument("input", help="Input text")
+    p.add_argument("--program", required=True, help="Program name or ID")
+    p.add_argument("--input", required=True, help="Input text")
     p.add_argument("--max-tokens", type=int, default=512)
     p.add_argument("--temperature", type=float, default=0.0)
     p.add_argument("--verbose", action="store_true")
+    p.add_argument("--json", action="store_true", help="JSON output")
+
+    p = sub.add_parser("login", help="Save API key for authentication")
+    p.add_argument("key", nargs="?", default=None, help="API key (paw_sk_...). Omit to open browser.")
 
-    # paw login
-    p = sub.add_parser("login", help="Authenticate with email")
-    p.add_argument("email", nargs="?", default=None, help="Email address")
+    p = sub.add_parser("rename", help="Set or change a program's slug")
+    p.add_argument("program", help="Program ID or current slug")
+    p.add_argument("new_slug", help="New slug (e.g. 'message-classifier') or empty string to remove")
+    p.add_argument("--json", action="store_true", help="JSON output")
 
-    # paw info
     p = sub.add_parser("info", help="Show program info")
-    p.add_argument("program_id", help="Program ID")
+    p.add_argument("program", help="Program name or ID")
+    p.add_argument("--json", action="store_true", help="JSON output")
 
     args = parser.parse_args()
 
@@ -126,6 +197,7 @@ def main():
         "compile": cmd_compile,
         "run": cmd_run,
         "login": cmd_login,
+        "rename": cmd_rename,
         "info": cmd_info,
     }
 

programasweights/client.py

@@ -23,6 +23,7 @@ class Program:
     """Result of a compilation."""
     id: str
     status: str
+    slug: Optional[str] = None
     compiler_snapshot: Optional[str] = None
     timings: Optional[dict] = None
     error: Optional[str] = None
@@ -48,27 +49,32 @@ class PAWClient:
         name: str | None = None,
         tags: list[str] | None = None,
         public: bool = True,
+        slug: str | None = None,
     ) -> Program:
         """Compile a spec into a neural program on the server.
 
         Args:
             spec: Natural language specification. Include examples in the text.
             compiler: Compiler name (alias or snapshot).
-            name: Human-readable program name.
+            name: Human-readable program name (display title).
             tags: Tags for hub discovery.
             public: Whether to list on the public hub.
+            slug: URL-safe handle (e.g. 'message-classifier'). Creates a
+                ``username/slug`` alias for easy reference. Requires auth.
 
         Returns:
-            Program with id, status, and timings.
+            Program with id, slug, status, and timings.
 
         Raises:
             httpx.HTTPStatusError: On API errors (422 for validation, 429 for rate limit).
         """
-        body = {"spec": spec, "compiler": compiler, "public": public}
+        body: dict = {"spec": spec, "compiler": compiler, "public": public}
         if name:
             body["name"] = name
         if tags:
             body["tags"] = tags
+        if slug:
+            body["slug"] = slug
 
         resp = httpx.post(
             f"{self._api_url}/api/v1/compile",
@@ -82,6 +88,7 @@ class PAWClient:
         return Program(
             id=data.get("program_id", ""),
             status=data.get("status", "unknown"),
+            slug=data.get("slug"),
             compiler_snapshot=data.get("compiler_snapshot"),
             timings=data.get("timings"),
             error=data.get("error"),

programasweights/runtime/interpreter_onnx.py

@@ -82,7 +82,7 @@ def download_onnx_models(model_name: str, download_image_encoder: bool = False)
     Downloads only required files (lazy loading for optional components).
     
     Args:
-        model_name: HuggingFace repo ID (e.g., "yuntian-deng/paw-interpreter-onnx")
+        model_name: HuggingFace repo ID (e.g., "programasweights/paw-interpreter-onnx")
                     OR local path to ONNX models directory
         download_image_encoder: If True, also download image encoder (default: False, lazy)
     

programasweights/runtime_llamacpp.py

@@ -3,13 +3,15 @@ llama.cpp runtime for local inference with LoRA adapters.
 
 Loads a base GGUF model (Q6_K) and applies a Q4_0 LoRA adapter per-program.
 Uses the pre-rendered prompt template from the .paw bundle.
+
+Prefix KV cache is saved to disk after the first call and reloaded on
+subsequent runs, eliminating the ~2-3s cold-start prefix evaluation.
 """
 
 from __future__ import annotations
 
 import json
 from pathlib import Path
-from typing import Callable
 
 import llama_cpp
 from llama_cpp import Llama
@@ -29,13 +31,13 @@ class PawFunction:
         self,
         program_dir: str | Path,
         n_ctx: int = 2048,
-        n_gpu_layers: int = -1,
+        n_gpu_layers: int = 0,
         verbose: bool = False,
     ):
         program_dir = Path(program_dir)
         self._program_dir = program_dir
+        self._verbose = verbose
 
-        # Load metadata
         meta_path = program_dir / "meta.json"
         if meta_path.exists():
             with open(meta_path) as f:
@@ -43,17 +45,14 @@ class PawFunction:
         else:
             self._meta = {}
 
-        # Load prompt template
         template_path = program_dir / "prompt_template.txt"
         if not template_path.exists():
             raise FileNotFoundError(f"No prompt_template.txt in {program_dir}")
         self._template = template_path.read_text()
 
-        # Get base model GGUF
         interpreter = self._meta.get("interpreter", "Qwen/Qwen3-0.6B")
         base_model_path = cache.get_base_model_path(interpreter)
 
-        # Load base model
         self._llm = Llama(
             model_path=str(base_model_path),
             n_ctx=n_ctx,
@@ -61,7 +60,6 @@ class PawFunction:
             verbose=verbose,
         )
 
-        # Load LoRA adapter
         adapter_path = program_dir / "adapter.gguf"
         if adapter_path.exists():
             self._adapter = llama_cpp.llama_adapter_lora_init(
@@ -74,6 +72,69 @@ class PawFunction:
         else:
             self._adapter = None
 
+        placeholder = "{INPUT_PLACEHOLDER}"
+        self._use_special = interpreter not in ("gpt2",)
+
+        if placeholder in self._template:
+            prefix_text = self._template.split(placeholder)[0]
+            suffix_text = self._template.split(placeholder)[1]
+        else:
+            prefix_text = self._template
+            suffix_text = ""
+
+        self._prefix_tokens = self._llm.tokenize(
+            prefix_text.encode("utf-8"),
+            add_bos=not self._use_special,
+            special=self._use_special,
+        )
+        self._suffix_text = suffix_text
+        self._n_prefix = len(self._prefix_tokens)
+
+        self._load_or_eval_prefix()
+
+    def _load_or_eval_prefix(self):
+        """Load prefix KV state from disk cache, or evaluate and save it."""
+        cache_path = self._program_dir / "prefix_kv_cache.bin"
+
+        if cache_path.exists():
+            try:
+                import ctypes
+                token_array = (llama_cpp.llama_token * self._n_prefix)(*self._prefix_tokens)
+                n_token_count = ctypes.c_size_t(0)
+                n_loaded = llama_cpp.llama_state_seq_load_file(
+                    self._llm.ctx,
+                    str(cache_path).encode("utf-8"),
+                    0,
+                    token_array,
+                    self._n_prefix,
+                    ctypes.byref(n_token_count),
+                )
+                if n_loaded > 0:
+                    self._llm.n_tokens = self._n_prefix
+                    self._llm.input_ids[:self._n_prefix] = self._prefix_tokens
+                    if self._verbose:
+                        print(f"Loaded prefix KV cache ({self._n_prefix} tokens) from disk")
+                    return
+            except Exception:
+                pass
+
+        self._llm.eval(self._prefix_tokens)
+
+        try:
+            token_array = (llama_cpp.llama_token * self._n_prefix)(*self._prefix_tokens)
+            result = llama_cpp.llama_state_seq_save_file(
+                self._llm.ctx,
+                str(cache_path).encode("utf-8"),
+                0,
+                token_array,
+                self._n_prefix,
+            )
+            if result and self._verbose:
+                size_mb = cache_path.stat().st_size / (1024 * 1024)
+                print(f"Saved prefix KV cache ({self._n_prefix} tokens, {size_mb:.1f} MB)")
+        except Exception:
+            pass
+
     def __call__(
         self,
         input_text: str,
@@ -90,20 +151,32 @@ class PawFunction:
         Returns:
             The program's output as a string.
         """
-        rendered = self._template.replace("{INPUT_PLACEHOLDER}", input_text)
-
-        token_ids = self._llm.tokenize(
-            rendered.encode("utf-8"), add_bos=False, special=True,
+        # Reset to prefix state: clear everything after the prefix
+        self._llm.n_tokens = self._n_prefix
+
+        input_with_suffix = input_text + self._suffix_text
+        input_tokens = self._llm.tokenize(
+            input_with_suffix.encode("utf-8"),
+            add_bos=False,
+            special=self._use_special,
         )
 
-        out = self._llm.create_completion(
-            prompt=token_ids,
-            max_tokens=max_tokens,
-            temperature=temperature if temperature > 0 else 0,
-            echo=False,
-        )
+        self._llm.eval(input_tokens)
+
+        output_tokens = []
+        for _ in range(max_tokens):
+            token = self._llm.sample(
+                temp=temperature if temperature > 0 else 0,
+            )
+
+            if token == self._llm.token_eos():
+                break
+
+            output_tokens.append(token)
+            self._llm.eval([token])
 
-        return out["choices"][0]["text"].strip()
+        output_bytes = self._llm.detokenize(output_tokens)
+        return output_bytes.decode("utf-8", errors="replace").strip()
 
     def __del__(self):
         if hasattr(self, "_adapter") and self._adapter:

programasweights-0.1.0.dev8.dist-info/METADATA

@@ -0,0 +1,142 @@
+Metadata-Version: 2.4
+Name: programasweights
+Version: 0.1.0.dev8
+Summary: Compile natural language specifications into neural programs that run locally via llama.cpp.
+Project-URL: Homepage, https://programasweights.com
+Project-URL: Repository, https://github.com/programasweights/programasweights-python
+Project-URL: Documentation, https://programasweights.readthedocs.io
+Project-URL: Bug Tracker, https://github.com/programasweights/programasweights-python/issues
+Author-email: ProgramAsWeights <support@programasweights.com>
+License: MIT
+Keywords: inference,llama-cpp,lora,neural-programs,nlp
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT 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
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: httpx<1.0,>=0.27.0
+Requires-Dist: llama-cpp-python<1.0,>=0.3.0
+Provides-Extra: test
+Requires-Dist: pytest; extra == 'test'
+Description-Content-Type: text/markdown
+
+# ProgramAsWeights
+
+**Compile natural language specs into tiny neural functions that run locally.**
+
+Define what a function should do in plain English. PAW compiles it into a small neural program that runs on your machine — no API keys at runtime, no internet needed after setup, fully deterministic.
+
+## Install
+
+```bash
+pip install programasweights
+```
+
+## Quick Start
+
+```python
+import programasweights as paw
+
+# Use a pre-compiled function (downloads once, runs locally forever)
+fn = paw.function("email-triage")
+fn("Urgent: the server is down!")        # "immediate"
+fn("Newsletter: spring picnic")          # "wait"
+
+# Compile your own from a description
+program = paw.compile(
+    "Fix malformed JSON: repair missing quotes and trailing commas",
+    compiler="paw-4b-qwen3-0.6b"  # or "paw-4b-gpt2" for smaller/faster
+)
+fn = paw.function(program.id)
+fn("{name: 'Alice',}")  # '{"name": "Alice"}'
+```
+
+## Two Compilers
+
+|                    | Standard (Qwen3 0.6B)   | Compact (GPT-2 124M)   |
+|--------------------|-------------------------|------------------------|
+| Compiler name      | `paw-4b-qwen3-0.6b`    | `paw-4b-gpt2`          |
+| Accuracy           | Higher                  | Lower                  |
+| Base model size    | 594 MB                  | 105 MB                 |
+| Program size       | ~22 MB                  | ~5 MB                  |
+| Inference speed    | ~90ms (server)          | ~50ms (server)         |
+| Runs in browser    | No                      | Yes                    |
+
+Default is Standard (Qwen3 0.6B). Use Compact (GPT-2) when you need smaller files or browser deployment.
+
+## Browser SDK
+
+Programs compiled with GPT-2 also run entirely in the browser via WebAssembly — no server needed, data never leaves the user's device.
+
+```bash
+npm install @programasweights/web
+```
+
+```javascript
+import paw from '@programasweights/web';
+
+const fn = await paw.function('programasweights/email-triage');
+const result = await fn('Urgent: the server is down!');
+// result: "immediate"
+```
+
+See the [browser SDK repo](https://github.com/programasweights/programasweights-js) for full documentation.
+
+## Use with AI Agents
+
+PAW works with Cursor, Claude, Codex, and other AI coding assistants. Paste this into your agent's chat:
+
+> I want to use ProgramAsWeights (PAW) to create fuzzy text functions that run locally. Read the instructions at https://programasweights.com/agents and help me integrate it.
+
+Or save [`AGENTS.md`](https://programasweights.com/agents) to your project root — agents read it automatically.
+
+## When to Use PAW
+
+- **Fuzzy search** — typo-tolerant matching, semantic search, near-duplicate detection
+- **Format repair** — fix broken JSON, normalize dates, repair malformed inputs
+- **Classification** — sentiment, urgency, categories defined in your own words
+- **Extraction** — emails, names, dates from messy unstructured text
+- **Log triage** — extract errors from verbose output, filter noise
+- **Intent routing** — map user descriptions to the closest URL, menu item, or setting
+- **Agent preprocessing** — parse tool calls, validate outputs, route tasks
+
+## Authentication
+
+```bash
+# Option 1: environment variable (recommended)
+export PAW_API_KEY=paw_sk_...
+
+# Option 2: CLI login (opens browser to generate key)
+paw login
+```
+
+Generate API keys at [programasweights.com/settings](https://programasweights.com/settings). Authenticated users get higher rate limits.
+
+## CLI
+
+```bash
+paw compile --spec "Extract error lines from logs" --json
+paw run --program <program_id> --input "[ERROR] timeout" --json
+paw login
+```
+
+`--json` gives structured output for programmatic use.
+
+## Links
+
+- **Website**: [programasweights.com](https://programasweights.com)
+- **Documentation**: [programasweights.readthedocs.io](https://programasweights.readthedocs.io)
+- **Python SDK**: [github.com/programasweights/programasweights-python](https://github.com/programasweights/programasweights-python)
+- **Browser SDK**: [github.com/programasweights/programasweights-js](https://github.com/programasweights/programasweights-js)
+- **Program Hub**: [programasweights.com/hub](https://programasweights.com/hub)
+
+## License
+
+MIT

{programasweights-0.1.0.dev6.dist-info → programasweights-0.1.0.dev8.dist-info}/RECORD

@@ -1,18 +1,18 @@
-programasweights/__init__.py,sha256=Sv7JjEKehJHLalI1Cvpx6cIoB0d74oEdZTvoiDwlLz0,5160
+programasweights/__init__.py,sha256=i6zgstkPcoxr00hkH_qWfFvBtRKaxjp87AUYirZeGp0,5952
 programasweights/artifacts.py,sha256=bSRZgYadAYyuH9aIW6P3VocExfGDGAHeDuj8vod5-Bo,1968
-programasweights/cache.py,sha256=5eXxonCfaEX0MvvffG_takwmB0nUCXtorb8Vp_B_p_4,2524
-programasweights/cli.py,sha256=nO896Xfhc_nWL2YaluxprIMTmPM6gP2F5MSPBZT_kJo,4043
-programasweights/client.py,sha256=1IAl1YL4P2wNbcVpy2cDqL4WjCL3Z2T1orNIXDtcrrw,4067
+programasweights/cache.py,sha256=69mOsx2Aqi3sQjFXjeBvhKySXDKdvKSINis2FprVDw4,3711
+programasweights/cli.py,sha256=_HCBRXfn9at7a4oTvVOAi2lPMMKaDxleLngdc6WKi2c,6480
+programasweights/client.py,sha256=Qk0ubKW54robuVnvEf0AyED5zX2Rw-W4HefBg_GQp8s,4391
 programasweights/config.py,sha256=zQFnVNfYR4bFx2DsZheMnPy2yd9T4-fe0u2sG1GluE8,1553
 programasweights/convert_peft_to_paw.py,sha256=yvavaAzLUqc-lFHEC_9AOhsuI-fCobu6k-GDMVQdOHk,6521
 programasweights/paw_format.py,sha256=wRXolwtnPgKoopiJC8-yMVZZtiwB-PoAqaWpDFKMoj8,10679
-programasweights/runtime_llamacpp.py,sha256=ErPsHMtic1t_JZkP66Zl4SXgJi7VBx0kd66s3xBjc_4,3701
+programasweights/runtime_llamacpp.py,sha256=UWcmhKF9iNA2r3gDIKxP5bcdJ2WUvSNilW0_aMfvmuo,6461
 programasweights/compiler/__init__.py,sha256=_q0L02k6Cl9zyvxKQlMuW2o6w7cX6OZ_bZ9wHuZqs18,9508
 programasweights/compiler/dummy.py,sha256=PcLwijRNM4q2E9PNUcfCPf_y08QjsteVENR0TVsOIfY,1011
 programasweights/runtime/__init__.py,sha256=S4jp7-eWAcMa0X417U7P6HkTL1j3v8ffQA-nneh9wY0,549
 programasweights/runtime/interpreter.py,sha256=brYCtatSsu23lq87cuki4MViqZX6U32LBw7Z3USbQmA,19632
-programasweights/runtime/interpreter_onnx.py,sha256=lim1FklSyP8Htx1UYLFCajdmOy3fbNaXpey1ryMfdr4,21555
-programasweights-0.1.0.dev6.dist-info/METADATA,sha256=2tU55n6X6W7TZoxRLvdUv4hxbXC4PoxFjW-m_ZpiN-A,4007
-programasweights-0.1.0.dev6.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-programasweights-0.1.0.dev6.dist-info/entry_points.txt,sha256=l4ZnfCPU0oMzhGB9T2Fv9AnDbSCMM70KUUJVtSvMJBc,50
-programasweights-0.1.0.dev6.dist-info/RECORD,,
+programasweights/runtime/interpreter_onnx.py,sha256=kzYKmwg_h0tVhoQlixJGKoHPVhcCK22AcHG59oeYX2Q,21559
+programasweights-0.1.0.dev8.dist-info/METADATA,sha256=yeRSFIIH216ZjEOEFlKTqIHN-BiyA1bFo_cXCnN3nls,5574
+programasweights-0.1.0.dev8.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+programasweights-0.1.0.dev8.dist-info/entry_points.txt,sha256=l4ZnfCPU0oMzhGB9T2Fv9AnDbSCMM70KUUJVtSvMJBc,50
+programasweights-0.1.0.dev8.dist-info/RECORD,,

programasweights-0.1.0.dev6.dist-info/METADATA

@@ -1,127 +0,0 @@
-Metadata-Version: 2.4
-Name: programasweights
-Version: 0.1.0.dev6
-Summary: Compile natural language specifications into neural programs that run locally via llama.cpp.
-Author-email: ProgramAsWeights <support@programasweights.com>
-License: MIT
-Keywords: inference,llama-cpp,lora,neural-programs,nlp
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: Intended Audience :: Science/Research
-Classifier: License :: OSI Approved :: MIT 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
-Classifier: Topic :: Software Development :: Libraries :: Python Modules
-Requires-Python: >=3.9
-Requires-Dist: httpx<1.0,>=0.27.0
-Requires-Dist: llama-cpp-python<1.0,>=0.3.0
-Provides-Extra: test
-Requires-Dist: pytest; extra == 'test'
-Description-Content-Type: text/markdown
-
-# ProgramAsWeights
-
-**Compile natural language specifications into neural programs (.paw files) that run locally.**
-
-Programs are stored as weight blobs (KV cache prefix + optional LoRA adapters) interpreted by a small fixed model. No API calls needed at runtime — fully deterministic, local execution.
-
-## Installation
-
-```bash
-pip install programasweights
-```
-
-## Quick Start
-
-### Run a Program
-
-```python
-import programasweights as paw
-
-# Load and run a compiled program
-fn = paw.function("program_id_or_path.paw")
-result = fn("Contact alice@company.com or bob@example.org")
-print(result)  # ["alice@company.com", "bob@example.org"]
-```
-
-### Compile a Program
-
-```python
-import programasweights as paw
-
-# Compile from natural language specification
-paw.compile(
-    "output.paw",
-    spec="Extract all email addresses from text and return as JSON list",
-    checkpoint_dir="path/to/trained/compiler",
-)
-```
-
-## LoRA Support (PEFT Compatible)
-
-Already using PEFT for LoRA training? Convert to .paw in one line:
-
-```python
-import programasweights as paw
-
-# Standard PEFT workflow:
-# model = get_peft_model(base_model, LoraConfig(r=16, target_modules=["q_proj", "v_proj"]))
-# trainer.train()
-# model.save_pretrained("my_adapter/")
-
-# Convert to .paw:
-paw.from_peft(
-    "my_adapter/",       # Your PEFT checkpoint
-    "sentiment.paw",     # Output .paw file
-    spec="Classify sentiment as positive or negative",
-    tags=["sentiment", "classification"],
-    examples=[
-        {"input": "Great movie!", "output": "positive"},
-        {"input": "Terrible film.", "output": "negative"},
-    ],
-)
-
-# Use it:
-fn = paw.function("sentiment.paw")
-print(fn("This is amazing!"))  # → "positive"
-```
-
-Load LoRA from a .paw file:
-
-```python
-lora_weights, lora_config = paw.load_paw_lora("sentiment.paw")
-print(lora_config)  # {"rank": 16, "alpha": 32, ...}
-```
-
-Or use `save_lora_to_paw()` directly if you have raw tensors instead of a PEFT checkpoint.
-
-## .paw File Format v2
-
-A `.paw` file is a self-contained neural program that includes:
-
-| Component | Description | Required |
-|-----------|-------------|----------|
-| KV cache prefix | Continuous program (prefix weights) | Optional |
-| Pseudo-program | Discrete text instructions | Optional |
-| LoRA adapter | Fine-tuned adapter weights | Optional |
-| Generation config | Temperature, top_p, max_tokens | Optional |
-| Metadata | Interpreter model, spec, author, tags | Required |
-
-## Program Hub
-
-Browse and share programs at [hub.programasweights.com](https://hub.programasweights.com)
-
-## Links
-
-- **Website**: [programasweights.com](https://programasweights.com)
-- **Documentation**: [programasweights.readthedocs.io](https://programasweights.readthedocs.io)
-- **GitHub**: [github.com/programasweights/programasweights](https://github.com/programasweights/programasweights)
-- **Program Hub**: [hub.programasweights.com](https://hub.programasweights.com)
-
-## License
-
-MIT