pal-code 0.1.0__py3-none-any.whl

pal/knowledge_graph/pipeline.py

@@ -0,0 +1,215 @@
+"""The Knowledge Graph component: send the relevant slice of a project, not the project.
+
+A zip of source code (or one large code file) attached to the chat is indexed once,
+locally, with graphify (AST only: no LLM call, nothing leaves the machine). After that
+each API request carries only the graph nodes and code excerpts that match the current
+question, within `budget_tokens`. The excerpts are added to the request but not stored
+in the chat history, so they are not resent on every later turn.
+
+Only source code is indexed. graphify's semantic extraction for docs and images needs
+an LLM and is not used here.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Optional
+
+from pal.config import KnowledgeGraphConfig
+from pal.knowledge_graph.components import builder, retriever, workspace
+from pal.knowledge_graph.components.base import (
+    GRAPH_NOTICE,
+    GraphError,
+    GraphExcerpts,
+    ProjectInfo,
+    Runner,
+)
+
+__all__ = ["KnowledgeGraph", "GraphBlock", "GraphError", "GraphExcerpts", "ProjectInfo", "GRAPH_NOTICE"]
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class GraphBlock:
+    """What the knowledge graph contributes to one request."""
+    text: str            # the excerpts, ready to add to the request
+    saved_tokens: int    # what sending the whole project would have cost, minus these excerpts
+    info: dict           # nodes, excerpts, tokens and project tokens, for the turn's report
+
+
+class KnowledgeGraph:
+    def __init__(self, cfg=None, runner: Optional[Runner] = None):
+        self.cfg = KnowledgeGraphConfig.coerce(cfg)
+        self.runner: Runner = runner or builder.default_runner
+        self.root = self.cfg.resolved_dir()
+
+    # -- config ------------------------------------------------------------------------
+    @property
+    def enabled(self) -> bool:
+        return self.cfg.enabled
+
+    def _ws(self, session_id: str) -> workspace.Workspace:
+        return workspace.Workspace(self.root, session_id)
+
+    def available(self) -> bool:
+        return self.runner is not builder.default_runner or builder.graphify_available()
+
+    def wants(self, name: str, raw: bytes) -> bool:
+        """Should this upload be indexed instead of pasted into the chat?"""
+        if not self.enabled:
+            return False
+        if workspace.ext(name) == "zip":
+            return True  # a zip can only be used as a project; fails clearly if graphify is missing
+        return (self.available() and workspace.is_code(name)
+                and len(raw) > self.cfg.min_code_file_chars)
+
+    # -- indexing --------------------------------------------------------------------------
+    def ingest(self, session_id: str, name: str, raw: bytes) -> dict:
+        """Index an upload; returns the attachment dict the chat should show the API model."""
+        if not self.available():
+            raise GraphError(f"{name}: indexing code needs graphify (pip install graphifyy)")
+        ws = self._ws(session_id)
+        try:
+            if workspace.ext(name) == "zip":
+                ws.add_zip(raw, self.cfg.max_zip_files, self.cfg.max_zip_mb * 1_000_000)
+            else:
+                ws.add_file(Path(name).name, raw)
+            info = builder.build(ws, Path(name).stem if workspace.ext(name) == "zip" else Path(name).name, self.runner)
+        except GraphError as e:
+            raise GraphError(f"{name}: {e}") from e
+        return {"name": name, "text": info.summary(), "note": "indexed as a code graph; source not included",
+                "kind": "project"}
+
+    def stats(self) -> dict:
+        """How many projects are indexed right now and how much disk they take (for the Memory Tracker)."""
+        from pal.memory_tracker import dir_bytes
+        projects = sum(1 for d in self.root.iterdir() if d.is_dir()) if self.root.is_dir() else 0
+        return {"enabled": self.enabled, "projects": projects, "bytes": dir_bytes(self.root) if projects else 0}
+
+    def has_project(self, session_id: str) -> bool:
+        return self.enabled and self._ws(session_id).exists()
+
+    # -- per-question ------------------------------------------------------------------------
+    def retrieve(self, session_id: str, question: str,
+                 count_tokens: Callable[[str], int]) -> Optional[GraphExcerpts]:
+        if not self.has_project(session_id) or not question.strip():
+            return None
+        return retriever.retrieve(self._ws(session_id), question, self.runner, count_tokens,
+                                  self.cfg.budget_tokens, self.cfg.max_slice_lines)
+
+    def context_block(self, session_id: str, question: str, count_tokens: Callable[[str], int]) -> Optional[GraphBlock]:
+        """The excerpts of the loaded project that match the question, as a block for the request, with the tokens saved against sending the whole
+        project. None when there is no project or nothing matches. A failure is logged and gives None: the chat never fails because the graph did."""
+        try:
+            ex = self.retrieve(session_id, question, count_tokens)
+        except Exception:  # noqa: BLE001
+            log.exception("graph retrieval failed")
+            return None
+        if not ex:
+            return None
+        return GraphBlock(ex.text, max(0, ex.project_tokens - ex.tokens),
+                          {"nodes": ex.nodes, "excerpts": ex.excerpts, "tokens": ex.tokens, "project_tokens": ex.project_tokens})
+
+    def read_source(self, session_id: str, path: str, start: int = 1, end: int = 0, max_lines: int = 120) -> str:
+        """Read-only view of one indexed source file (used by the read_source tool)."""
+        from pal.errors import NotFoundError
+        from pal.paths import is_safe_relative_key
+        ws = self._ws(session_id)
+        rel = path.strip().replace("\\", "/").removeprefix("src/")
+        if not ws.exists() or not is_safe_relative_key(rel):
+            raise NotFoundError(f"no such file in the project: {path!r}")
+        target = (ws.src / rel).resolve()
+        if ws.src.resolve() not in target.parents or not target.is_file() or not workspace.is_code(target.name):
+            raise NotFoundError(f"no such file in the project: {path!r}")
+        lines = target.read_text(encoding="utf-8", errors="replace").splitlines()
+        start = max(1, start)
+        end = min(len(lines), end if end >= start else start + max_lines - 1, start + max_lines - 1)
+        body = "\n".join(f"{i}: {lines[i - 1]}" for i in range(start, end + 1))
+        return f"[{rel} lines {start}-{end} of {len(lines)}]\n{body}"
+
+    # -- read-only code navigation, no model involved ---------------------------------------------------------------------
+    def _code_files(self, session_id: str) -> list:
+        ws = self._ws(session_id)
+        if not ws.exists():
+            return []
+        return sorted(p for p in ws.src.rglob("*") if p.is_file() and workspace.is_code(p.name))
+
+    def list_files(self, session_id: str, prefix: str = "", limit: int = 200) -> str:
+        """The project's source files, one per line with the line count."""
+        ws = self._ws(session_id)
+        rows = []
+        for p in self._code_files(session_id):
+            rel = p.relative_to(ws.src).as_posix()
+            if rel.startswith(prefix.strip().lstrip("/")):
+                rows.append(f"{rel} ({sum(1 for _ in p.open(encoding='utf-8', errors='replace'))} lines)")
+        if not rows:
+            return "no files match" if prefix else "no project"
+        more = f"\n[{len(rows) - limit} more not shown: use a prefix]" if len(rows) > limit else ""
+        return "\n".join(rows[:limit]) + more
+
+    def search(self, session_id: str, text: str, limit: int = 25) -> str:
+        """Lines containing `text` (case-insensitive), as path:line: text."""
+        needle = text.strip().lower()
+        if len(needle) < 2:
+            return "give at least two characters to search for"
+        return self._grep(session_id, lambda line: needle in line.lower(), limit, f"search for {text.strip()!r}")
+
+    def find_usages(self, session_id: str, symbol: str, limit: int = 25) -> str:
+        """Where a function, class or variable is defined and where its name is used (a word-boundary text match)."""
+        import re
+        sym = symbol.strip()
+        if not re.fullmatch(r"[A-Za-z_$][\w$.]*", sym):
+            return "give a plain name: letters, digits, underscore"
+        word = re.compile(rf"(?<![\w$]){re.escape(sym.split('.')[-1])}(?![\w$])")
+        define = re.compile(rf"^\s*(?:export\s+|async\s+|public\s+|private\s+|static\s+)*(?:def|class|function|func|fn|interface|struct|enum|trait|type)\s+"
+                            rf"{re.escape(sym.split('.')[-1])}\b")
+        defs, uses = [], []
+        for p in self._code_files(session_id):
+            rel = p.relative_to(self._ws(session_id).src).as_posix()
+            for n, line in enumerate(p.read_text(encoding="utf-8", errors="replace").splitlines(), 1):
+                if word.search(line):
+                    (defs if define.match(line) else uses).append(f"{rel}:{n}: {line.strip()[:160]}")
+        if not defs and not uses:
+            return f"no match for {sym!r} in the project"
+        files = len({u.split(':')[0] for u in defs + uses})
+        out = [f"{sym}: {len(defs)} definition(s), {len(uses)} other use(s), in {files} file(s)"]
+        out += [f"definition: {d}" for d in defs[:5]]
+        out += uses[:limit]
+        if len(uses) > limit:
+            out.append(f"[{len(uses) - limit} more uses not shown]")
+        return "\n".join(out)
+
+    def _grep(self, session_id: str, test, limit: int, what: str) -> str:
+        ws = self._ws(session_id)
+        hits = []
+        for p in self._code_files(session_id):
+            rel = p.relative_to(ws.src).as_posix()
+            for n, line in enumerate(p.read_text(encoding="utf-8", errors="replace").splitlines(), 1):
+                if test(line):
+                    hits.append(f"{rel}:{n}: {line.strip()[:160]}")
+        if not hits:
+            return f"no results for {what}"
+        extra = f"\n[{len(hits) - limit} more results not shown]" if len(hits) > limit else ""
+        return "\n".join(hits[:limit]) + extra
+
+    def reset(self, session_id: str) -> None:
+        self._ws(session_id).reset()
+
+    def prune_stale(self, max_age_seconds: float) -> int:
+        """Delete indexed projects nobody has touched for `max_age_seconds` (left behind by a crash or a
+        request that failed after the upload). Returns how many were removed."""
+        import shutil
+        import time
+        removed = 0
+        if not self.root.is_dir():
+            return 0
+        for d in self.root.iterdir():
+            try:
+                if d.is_dir() and time.time() - d.stat().st_mtime > max_age_seconds:
+                    shutil.rmtree(d, ignore_errors=True)
+                    removed += 1
+            except OSError:
+                continue
+        return removed

pal/knowledge_graph/utils/__init__.py

@@ -0,0 +1 @@
+

pal/latency_tracker/__init__.py

@@ -0,0 +1,3 @@
+from pal.latency_tracker.pipeline import STAGES, LatencyTracker, percentile
+
+__all__ = ["STAGES", "LatencyTracker", "percentile"]

pal/latency_tracker/pipeline.py

@@ -0,0 +1,86 @@
+"""The Latency Tracker: where does the time of a chat turn go?
+
+Each turn is timed in stages, so a slow turn can be explained rather than guessed at:
+
+    direct        a question answered by code (arithmetic, the time), no model
+    routing       the local model deciding who answers
+    local_answer  the local model answering
+    input_saver   the local model trimming what was typed (and the check that it lost nothing)
+    context       gathering the request: history, notes, document and code excerpts
+    api           the API model, with its wait in the queue
+    tools         tool rounds (a tool call and the model call that follows it)
+    other         everything else (the turn's total minus the above)
+
+`stage()` times a block into the turn's record; `finish()` adds the stages that were already measured elsewhere and the remainder;
+`summarize()` turns a list of turns into per-route latency, queue waits, pauses, and each stage's average, 95th percentile and share of
+all the time spent.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Iterable
+from contextlib import contextmanager
+
+STAGES = ("direct", "routing", "local_answer", "input_saver", "context", "api", "tools", "other")
+
+
+def percentile(values: list[float], p: float) -> float:
+    if not values:
+        return 0.0
+    v = sorted(values)
+    return v[min(len(v) - 1, int(round(p * (len(v) - 1))))]
+
+
+class LatencyTracker:
+    @staticmethod
+    @contextmanager
+    def stage(turn, name: str):
+        """Time the block and add it to the turn's `stage_seconds[name]` (a stage can be entered more than once in a turn)."""
+        if name not in STAGES:
+            raise KeyError(f"unknown stage {name!r} (known: {', '.join(STAGES)})")
+        start = time.perf_counter()
+        try:
+            yield
+        finally:
+            turn.stage_seconds[name] = turn.stage_seconds.get(name, 0.0) + (time.perf_counter() - start)
+
+    @staticmethod
+    def finish(turn) -> None:
+        """Close the turn's record: the API and tool times measured elsewhere, and `other` = the total minus every named stage."""
+        st = turn.stage_seconds
+        if "api" not in st and turn.latency_api:
+            st["api"] = turn.latency_api
+        if "tools" not in st and turn.latency_tools:
+            st["tools"] = turn.latency_tools
+        named = sum(v for k, v in st.items() if k != "other")
+        st["other"] = max(0.0, turn.latency_total - named)
+        for k in list(st):
+            st[k] = round(st[k], 4)
+
+    @staticmethod
+    def summarize(turns: Iterable) -> dict:
+        turns = list(turns)
+        n = len(turns)
+        by_route: dict = {}
+        for r in ("api", "local", "tool"):
+            lat = [t.latency_total for t in turns if t.route == r]
+            by_route[r] = {"turns": len(lat), "avg_latency_sec": round(sum(lat) / len(lat), 3) if lat else 0.0,
+                           "p50_latency_sec": round(percentile(lat, 0.5), 3), "p95_latency_sec": round(percentile(lat, 0.95), 3)}
+        api_turns = [t for t in turns if t.route == "api"]
+        total_time = sum(t.latency_total for t in turns)
+        stages: dict = {}
+        for name in STAGES:
+            vals = [t.stage_seconds[name] for t in turns if t.stage_seconds.get(name, 0) > 0]
+            if vals:
+                stages[name] = {"turns": len(vals), "mean_sec": round(sum(vals) / len(vals), 3), "p95_sec": round(percentile(vals, 0.95), 3),
+                                "total_sec": round(sum(vals), 3), "share_pct": round(100.0 * sum(vals) / total_time, 1) if total_time else 0.0}
+        slowest = max(stages, key=lambda k: stages[k]["total_sec"]) if stages else ""
+        return {
+            "by_route": by_route,
+            "avg_local_overhead_sec_on_api_turns": round(sum(t.latency_local for t in api_turns) / len(api_turns), 3) if api_turns else 0.0,
+            "avg_wait_local_sec": round(sum(t.wait_local for t in turns) / n, 3) if n else 0.0,
+            "avg_wait_api_sec": round(sum(t.wait_api for t in api_turns) / len(api_turns), 3) if api_turns else 0.0,
+            "local_pauses": sum(t.local_pauses for t in turns),
+            "latency_stages": stages,
+            "slowest_stage": slowest,
+        }

pal/llm_scheduler/__init__.py

@@ -0,0 +1,11 @@
+"""Scheduling. API model: first come, first served, one line per API key. Local model: preemptive priority (agent, then chat,
+then other), first come first served inside each class. Code work: a small pool of slots beside both."""
+from pal.llm_scheduler.api import ApiLine, ApiScheduler, is_rate_limit
+from pal.llm_scheduler.code import CodeSlots
+from pal.llm_scheduler.core import ScheduledWrapper, current_stats, task, track
+from pal.llm_scheduler.local import LocalScheduler
+from pal.llm_scheduler.pipeline import LLMScheduler
+from pal.llm_scheduler.types import ExpiredError, QueueFullError, SchedulerError, TaskClass, Ticket, TurnStats
+
+__all__ = ["ApiLine", "ApiScheduler", "CodeSlots", "ExpiredError", "LocalScheduler", "QueueFullError", "ScheduledWrapper",
+           "LLMScheduler", "SchedulerError", "TaskClass", "Ticket", "TurnStats", "current_stats", "is_rate_limit", "task", "track"]

pal/llm_scheduler/api.py

@@ -0,0 +1,137 @@
+"""The API model's scheduler: first come, first served, one call at a time, per API key.
+
+With one key there is one line, and chat, the coding agent and the documentation agent all wait in it, strictly in the order
+they arrive. Two things protect a free tier: calls start at least `interval` seconds apart, and a rate-limit error (429,
+quota) pauses the line and retries the same call after a growing delay instead of failing everyone behind it.
+"""
+from __future__ import annotations
+
+import logging
+import threading
+import time
+from collections import deque
+from collections.abc import Callable
+from typing import Any
+
+from pal.llm_scheduler.types import QueueFullError, SchedulerError, Ticket
+
+log = logging.getLogger(__name__)
+
+
+def is_rate_limit(error: BaseException) -> bool:
+    for attr in ("status_code", "code"):
+        if getattr(error, attr, None) == 429:
+            return True
+    resp = getattr(error, "response", None)
+    if getattr(resp, "status_code", None) == 429:
+        return True
+    low = str(error).lower()
+    return any(k in low for k in ("429", "resource_exhausted", "rate limit", "quota"))
+
+
+class _ApiJob:
+    def __init__(self, ticket: Ticket, fn: Callable[[], Any]):
+        self.ticket, self.fn = ticket, fn
+
+
+class ApiLine:
+    def __init__(self, interval: float, retries: int, backoff: float, max_queue: int):
+        self.interval, self.retries, self.backoff, self.max_queue = interval, retries, backoff, max_queue
+        self._queue: deque[_ApiJob] = deque()
+        self._cond = threading.Condition()
+        self._closed = False
+        self._thread = threading.Thread(target=self._worker, name="pal-api-line", daemon=True)
+        self._thread.start()
+
+    def submit(self, fn: Callable[[], Any], label: str = "api call") -> Ticket:
+        t = Ticket(label)
+        with self._cond:
+            if self._closed:
+                raise SchedulerError("the scheduler is closed")
+            if len(self._queue) >= self.max_queue:
+                raise QueueFullError(f"too many API calls are waiting ({self.max_queue})")
+            self._queue.append(_ApiJob(t, fn))
+            self._cond.notify()
+        return t
+
+    def pending(self) -> int:
+        with self._cond:
+            return len(self._queue)
+
+    def _worker(self) -> None:
+        last_start = 0.0
+        while True:
+            with self._cond:
+                while not self._queue:
+                    if self._closed:
+                        return
+                    self._cond.wait()
+                job = self._queue.popleft()
+            gap = self.interval - (time.monotonic() - last_start)
+            if gap > 0:
+                time.sleep(gap)
+            t = job.ticket
+            t.started = last_start = time.monotonic()
+            attempt = 0
+            while True:
+                began = time.monotonic()
+                try:
+                    value = job.fn()
+                except BaseException as e:  # noqa: BLE001  (the caller gets the original error)
+                    t.run_seconds += time.monotonic() - began
+                    if is_rate_limit(e) and attempt < self.retries and not self._closed:
+                        delay = self.backoff * (2 ** attempt)
+                        attempt += 1
+                        log.warning("rate limit on the API line: waiting %.1f s, then retry %d of %d", delay, attempt, self.retries)
+                        time.sleep(delay)
+                        last_start = time.monotonic()
+                        continue
+                    t.set_error(e)
+                    break
+                t.run_seconds += time.monotonic() - began
+                t.set_result(value)
+                break
+
+    def close(self) -> None:
+        with self._cond:
+            self._closed = True
+            dropped = list(self._queue)
+            self._queue.clear()
+            self._cond.notify_all()
+        for j in dropped:
+            j.ticket.set_error(SchedulerError("the scheduler was closed"))
+
+
+class ApiScheduler:
+    """One ApiLine per API key (the key is part of the line name), created on first use."""
+
+    def __init__(self, retries: int = 2, backoff: float = 5.0, max_queue: int = 100, enabled: bool = True):
+        self.retries, self.backoff, self.max_queue, self.enabled = retries, backoff, max_queue, enabled
+        self._lines: dict[str, ApiLine] = {}
+        self._lock = threading.Lock()
+
+    def submit(self, line_key: str, fn: Callable[[], Any], interval: float = 0.0, label: str = "api call") -> Ticket:
+        if not self.enabled:                       # scheduling off: run right here, no line
+            t = Ticket(label)
+            t.started = time.monotonic()
+            try:
+                t.set_result(fn())
+            except BaseException as e:  # noqa: BLE001
+                t.set_error(e)
+            return t
+        with self._lock:
+            line = self._lines.get(line_key)
+            if line is None:
+                line = self._lines[line_key] = ApiLine(interval, self.retries, self.backoff, self.max_queue)
+            line.interval = interval
+        return line.submit(fn, label)
+
+    def pending(self) -> dict[str, int]:
+        with self._lock:
+            return {k: ln.pending() for k, ln in self._lines.items()}
+
+    def close(self) -> None:
+        with self._lock:
+            lines, self._lines = list(self._lines.values()), {}
+        for ln in lines:
+            ln.close()

pal/llm_scheduler/code.py

@@ -0,0 +1,28 @@
+"""Code work (converting files, building the code graph) runs in code, beside the LLM lines. It does not wait for the model,
+but it uses the CPU the local model also needs, so only a few run at once."""
+from __future__ import annotations
+
+import threading
+from collections.abc import Callable
+from typing import Any
+
+
+class CodeSlots:
+    def __init__(self, workers: int = 2):
+        self._sem = threading.BoundedSemaphore(workers) if workers > 0 else None
+        self._lock = threading.Lock()
+        self.running = 0
+        self.peak = 0
+
+    def run(self, fn: Callable[[], Any]) -> Any:
+        if self._sem is None:
+            return fn()
+        with self._sem:
+            with self._lock:
+                self.running += 1
+                self.peak = max(self.peak, self.running)
+            try:
+                return fn()
+            finally:
+                with self._lock:
+                    self.running -= 1

pal/llm_scheduler/core.py

@@ -0,0 +1,92 @@
+"""ScheduledWrapper: puts the local model behind the local scheduler without changing the code that uses it.
+
+Anything that calls `core.chat(...)` (the router, the input savers, the verifier) keeps working; the call becomes a job in the
+right class. The class comes from the turn that is running (`task(...)`), set once by the chat service.
+"""
+from __future__ import annotations
+
+import contextvars
+from collections.abc import Iterator
+from contextlib import contextmanager
+from typing import Any
+
+from pal.llm_scheduler.local import LocalScheduler
+from pal.llm_scheduler.types import TaskClass, TurnStats
+from pal.llm_wrapper.components.base import LLMResponse, LLMSyscall, LLMWrapper, WrapperCapabilities
+from pal.tokens import estimate_tokens
+
+_task: contextvars.ContextVar[tuple[TaskClass, bool]] = contextvars.ContextVar("pal_task", default=(TaskClass.CHAT, False))
+_stats: contextvars.ContextVar[TurnStats | None] = contextvars.ContextVar("pal_turn_stats", default=None)
+
+
+@contextmanager
+def task(task_class: TaskClass, preemptible: bool = False) -> Iterator[None]:
+    """Everything the local model is asked inside this block belongs to `task_class`. With `preemptible`, a plain-text
+    generation may be paused and resumed (only for cores that really stream)."""
+    token = _task.set((task_class, preemptible))
+    try:
+        yield
+    finally:
+        _task.reset(token)
+
+
+@contextmanager
+def track() -> Iterator[TurnStats]:
+    stats = TurnStats()
+    token = _stats.set(stats)
+    try:
+        yield stats
+    finally:
+        _stats.reset(token)
+
+
+def current_stats() -> TurnStats | None:
+    return _stats.get()
+
+
+def _streams(core: LLMWrapper) -> bool:
+    return type(core).stream_chat is not LLMWrapper.stream_chat
+
+
+class ScheduledWrapper(LLMWrapper):
+    name = "scheduled"
+
+    def __init__(self, core: LLMWrapper, scheduler: LocalScheduler | None):
+        self.core = core
+        self.scheduler = scheduler
+        self.config: Any = getattr(core, "config", None)
+
+    def chat(self, syscall: LLMSyscall) -> LLMResponse:
+        if self.scheduler is None:
+            return self.core.chat(syscall)
+        cls, preemptible = _task.get()
+        if preemptible and _streams(self.core):
+            ticket = self.scheduler.submit_stream(self.core, syscall, cls)
+            text = ticket.result()
+            prompt = estimate_tokens(" ".join(str(m.get("content", "")) for m in syscall.messages))
+            resp = LLMResponse(text=text, prompt_tokens=prompt, completion_tokens=estimate_tokens(text),
+                               meta={"streamed": True, "pauses": ticket.pauses})
+        else:
+            ticket = self.scheduler.submit(lambda: self.core.chat(syscall), cls)
+            resp = ticket.result()
+        stats = _stats.get()
+        if stats is not None:
+            stats.add_local(ticket)
+        return resp
+
+    def stream_chat(self, syscall: LLMSyscall):
+        return self.core.stream_chat(syscall)
+
+    def token_count(self, text: str) -> int:
+        return self.core.token_count(text)
+
+    def embed(self, texts: list[str]) -> list[list[float]]:
+        return self.core.embed(texts)
+
+    def capabilities(self) -> WrapperCapabilities:
+        return self.core.capabilities()
+
+    def __getattr__(self, name: str) -> Any:        # e.g. init_beam_search on in-process cores
+        if name in ("core", "scheduler", "config"):
+            raise AttributeError(name)
+        return getattr(self.core, name)