meshapi-code 0.2.1__tar.gz → 0.3.0__tar.gz

{meshapi_code-0.2.1 → meshapi_code-0.3.0}/.gitignore

@@ -4,6 +4,7 @@ __pycache__/
 *.egg-info/
 .venv/
 venv/
+.build-venv/
 dist/
 build/
 .pytest_cache/

{meshapi_code-0.2.1 → meshapi_code-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshapi-code
-Version: 0.2.1
+Version: 0.3.0
 Summary: Terminal chat for Mesh API — OpenAI-compatible LLM gateway
 Project-URL: Homepage, https://meshapi.ai
 Project-URL: Documentation, https://docs.meshapi.ai

{meshapi_code-0.2.1 → meshapi_code-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "meshapi-code"
-version = "0.2.1"
+version = "0.3.0"
 description = "Terminal chat for Mesh API — OpenAI-compatible LLM gateway"
 readme = "README.md"
 license = { text = "MIT" }

meshapi_code-0.3.0/src/meshapi/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

meshapi_code-0.3.0/src/meshapi/cli.py

@@ -0,0 +1,254 @@
+"""meshapi — terminal chat REPL for Mesh API."""
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import httpx
+from prompt_toolkit import PromptSession
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.history import FileHistory
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.styles import Style
+from rich.text import Text
+
+from . import __version__
+from .client import stream_chat
+from .commands import handle_command
+from .config import CONFIG_FILE, HISTORY_FILE, load_config
+from .permissions import HINTS, LABELS, Mode, from_str, next_mode
+from .render import (
+    BRAND, BRAND_BG, BRAND_BG_FG, BRAND_DIM, console, fmt_usd, pretty_cwd, render_stream,
+)
+from .tools import TOOLS, build_system_prompt, execute as exec_tool, summarize_call
+
+# ANSI Shadow figlet font
+MESH_LOGO_LINES = [
+    "███╗   ███╗███████╗███████╗██╗  ██╗",
+    "████╗ ████║██╔════╝██╔════╝██║  ██║",
+    "██╔████╔██║█████╗  ███████╗███████║",
+    "██║╚██╔╝██║██╔══╝  ╚════██║██╔══██║",
+    "██║ ╚═╝ ██║███████╗███████║██║  ██║",
+    "╚═╝     ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝",
+]
+LOGO_WIDTH = 35  # chars per line
+LOGO_GUTTER = 3  # spaces between logo and info column
+
+def parse_args(argv=None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(prog="meshapi", description="Terminal chat for Mesh API")
+    p.add_argument("--version", action="version", version=f"meshapi {__version__}")
+    p.add_argument("--model", help="Override model for this session (e.g. openai/gpt-4o-mini)")
+    p.add_argument("--route", choices=["cheapest", "fastest", "balanced"], help="Routing mode")
+    p.add_argument(
+        "--mode",
+        choices=[m.value for m in Mode],
+        default="ask",
+        help="Tool permission mode (default: ask). Cycle in-session with shift+tab.",
+    )
+    return p.parse_args(argv)
+
+
+def render_banner(cfg: dict) -> None:
+    info_per_line: list = [
+        None,
+        None,
+        Text.from_markup(f"[bold {BRAND}]✦  meshapi {__version__}[/bold {BRAND}]"),
+        Text.from_markup(f"cwd:   [{BRAND}]{pretty_cwd()}[/{BRAND}]"),
+        Text.from_markup(f"model: [bold {BRAND}]{cfg['model']}[/bold {BRAND}]"),
+        Text.from_markup(f"route: [{BRAND}]{cfg.get('route') or 'default'}[/{BRAND}]"),
+    ]
+    console.print()
+    for i, logo_line in enumerate(MESH_LOGO_LINES):
+        line = Text()
+        line.append(logo_line, style=BRAND)
+        info = info_per_line[i] if i < len(info_per_line) else None
+        if info is not None:
+            pad = max(0, LOGO_WIDTH - len(logo_line))
+            line.append(" " * (pad + LOGO_GUTTER))
+            line.append(info)
+        console.print(line)
+    console.print()
+    console.print("type /help for commands, /exit to quit", style=BRAND_DIM)
+    console.print()
+
+
+def confirm_tool_call(name: str, args: dict) -> bool:
+    """ASK-mode prompt for a single tool call. Returns True if approved."""
+    summary = summarize_call(name, args)
+    console.print(f"[bold {BRAND}]⚙ approve tool call?[/bold {BRAND}]  [dim]{summary}[/dim]")
+    if name == "write_file":
+        preview = (args.get("content") or "")[:300]
+        console.print(f"[dim]──[/dim]\n{preview}{'…' if len(args.get('content') or '') > 300 else ''}\n[dim]──[/dim]")
+    elif name == "run_bash":
+        console.print(f"[dim]$ {args.get('command')}[/dim]")
+    try:
+        ans = console.input("[bold]y[/bold] (yes) / [bold]n[/bold] (no)  › ").strip().lower()
+    except (KeyboardInterrupt, EOFError):
+        return False
+    return ans in ("y", "yes")
+
+
+def handle_tool_calls(tool_calls: list, mode: Mode, state: dict) -> None:
+    """Append assistant tool_calls message + tool result messages to state."""
+    state["messages"].append({
+        "role": "assistant",
+        "content": None,
+        "tool_calls": [
+            {
+                "id": tc["id"],
+                "type": "function",
+                "function": {"name": tc["name"], "arguments": tc["arguments"]},
+            }
+            for tc in tool_calls
+        ],
+    })
+    for tc in tool_calls:
+        try:
+            args = json.loads(tc["arguments"]) if tc["arguments"] else {}
+        except json.JSONDecodeError:
+            args = {}
+        approved = mode == Mode.BYPASS or confirm_tool_call(tc["name"], args)
+        if approved:
+            console.print(f"[{BRAND_DIM}]⚙ {summarize_call(tc['name'], args)}[/{BRAND_DIM}]")
+            result = exec_tool(tc["name"], args)
+            preview = result[:200].replace("\n", " ")
+            tail = "…" if len(result) > 200 else ""
+            console.print(f"[dim]  → {preview}{tail}[/dim]")
+        else:
+            result = "User denied this tool call."
+            console.print(f"[dim]  → denied by user[/dim]")
+        state["messages"].append({
+            "role": "tool",
+            "tool_call_id": tc["id"],
+            "content": result,
+        })
+
+
+def main() -> None:
+    args = parse_args()
+    cfg = load_config()
+    if args.model:
+        cfg["model"] = args.model
+    if args.route:
+        cfg["route"] = args.route
+
+    if not cfg["api_key"]:
+        console.print(
+            "[red]No API key found. Set MESHAPI_API_KEY env var or edit "
+            f"{CONFIG_FILE}[/red]"
+        )
+        sys.exit(1)
+
+    state = {
+        "cfg": cfg,
+        "messages": [{"role": "system", "content": build_system_prompt(cfg)}],
+        "session_cost": 0.0,
+        "mode": from_str(args.mode),
+    }
+
+    kb = KeyBindings()
+
+    @kb.add("s-tab")  # Shift+Tab
+    def _(event):
+        state["mode"] = next_mode(state["mode"])
+        event.app.invalidate()
+
+    def bottom_toolbar():
+        m = state["mode"]
+        color = "ansired" if m == Mode.BYPASS else "ansiyellow" if m == Mode.NONE else "ansigreen"
+        return FormattedText([
+            ("", "  mode: "),
+            (f"bold {color}", LABELS[m]),
+            ("", f"   {HINTS[m]}   "),
+            ("ansibrightblack", "shift+tab to cycle"),
+        ])
+
+    session = PromptSession(
+        history=FileHistory(str(HISTORY_FILE)),
+        key_bindings=kb,
+        bottom_toolbar=bottom_toolbar,
+    )
+
+    render_banner(cfg)
+
+    while True:
+        try:
+            console.rule(
+                title=f"[{BRAND_DIM}]{Path.cwd().name}[/{BRAND_DIM}]",
+                align="right",
+                style=BRAND_DIM,
+                characters="─",
+            )
+            user_input = session.prompt(
+                "› ",
+                style=Style.from_dict({
+                    "prompt": f"bold fg:{BRAND} bg:{BRAND_BG}",
+                    "": f"fg:{BRAND_BG_FG} bg:{BRAND_BG}",
+                    "bottom-toolbar": f"fg:{BRAND_BG_FG} bg:{BRAND_BG}",
+                }),
+            )
+            console.rule(style=BRAND_DIM, characters="─")
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[dim]bye[/dim]")
+            break
+
+        if not user_input.strip():
+            continue
+        if user_input.startswith("/"):
+            if not handle_command(user_input, state):
+                break
+            continue
+
+        state["messages"].append({"role": "user", "content": user_input})
+        console.print()
+
+        # Tool-calling loop: keep streaming until model returns text without tool_calls.
+        agg_cost = 0.0
+        last_model = state["cfg"]["model"]
+        last_usage: dict = {}
+        last_elapsed = 0.0
+        try:
+            for _hop in range(8):  # safety cap
+                tools_arg = TOOLS if state["mode"] != Mode.NONE else None
+                reply, meta = render_stream(
+                    stream_chat(state["messages"], state["cfg"], tools=tools_arg)
+                )
+                cost = meta.get("cost")
+                if cost is not None:
+                    try:
+                        agg_cost += float(cost)
+                    except (TypeError, ValueError):
+                        pass
+                last_model = meta.get("model") or last_model
+                last_usage = meta.get("usage") or last_usage
+                last_elapsed += meta.get("elapsed", 0.0)
+
+                tool_calls = meta.get("tool_calls") or []
+                if not tool_calls:
+                    state["messages"].append({"role": "assistant", "content": reply})
+                    break
+
+                # Model called tools — execute and loop.
+                handle_tool_calls(tool_calls, state["mode"], state)
+
+            state["session_cost"] += agg_cost
+            prompt_t = last_usage.get("prompt_tokens", "?")
+            completion_t = last_usage.get("completion_tokens", "?")
+            cost_str = fmt_usd(agg_cost) if agg_cost else "—"
+            console.rule(style=BRAND_DIM, characters="─")
+            console.print(
+                f"[dim]{last_model}  •  {prompt_t}→{completion_t} tok  •  {cost_str}  •  "
+                f"session {fmt_usd(state['session_cost'])}  •  {last_elapsed:.1f}s[/dim]"
+            )
+        except httpx.HTTPStatusError as e:
+            console.rule(style="dim red", characters="─")
+            console.print(f"[red]API error {e.response.status_code}: {e.response.text}[/red]")
+            state["messages"].pop()
+        except Exception as e:
+            console.rule(style="dim red", characters="─")
+            console.print(f"[red]Error: {e}[/red]")
+            state["messages"].pop()
+
+
+if __name__ == "__main__":
+    main()

meshapi_code-0.3.0/src/meshapi/client.py

@@ -0,0 +1,87 @@
+"""Streaming OpenAI-compatible HTTP client for Mesh API."""
+import json
+from typing import Iterable, Optional
+
+import httpx
+
+
+def stream_chat(
+    messages: list,
+    cfg: dict,
+    tools: Optional[list] = None,
+) -> Iterable:
+    """Yield content deltas, then a final dict with usage/cost/model/tool_calls.
+
+    Mesh API is OpenAI-compatible:
+      - `cost` arrives in the final SSE chunk alongside `usage`.
+      - `tool_calls` arrive as deltas indexed by position; we accumulate them
+        and surface as the meta dict's `tool_calls` field.
+    """
+    url = f"{cfg['base_url']}/chat/completions"
+    headers = {
+        "Authorization": f"Bearer {cfg['api_key']}",
+        "Content-Type": "application/json",
+    }
+    payload: dict = {
+        "model": cfg["model"],
+        "messages": messages,
+        "stream": True,
+    }
+    if cfg.get("route"):
+        payload["route"] = cfg["route"]
+    if tools:
+        payload["tools"] = tools
+        payload["tool_choice"] = "auto"
+
+    last_meta: dict = {}
+    last_model: str = ""
+    tool_calls_accum: dict = {}  # index -> {id, name, arguments}
+
+    with httpx.stream("POST", url, json=payload, headers=headers, timeout=120) as r:
+        r.raise_for_status()
+        for line in r.iter_lines():
+            if not line or not line.startswith("data: "):
+                continue
+            data = line[6:]
+            if data.strip() == "[DONE]":
+                break
+            try:
+                obj = json.loads(data)
+            except json.JSONDecodeError:
+                continue
+
+            if obj.get("model"):
+                last_model = obj["model"]
+
+            choices = obj.get("choices") or []
+            if choices:
+                delta = choices[0].get("delta", {})
+
+                content = delta.get("content")
+                if content:
+                    yield content
+
+                for tc in delta.get("tool_calls") or []:
+                    idx = tc.get("index", 0)
+                    bucket = tool_calls_accum.setdefault(
+                        idx, {"id": "", "name": "", "arguments": ""}
+                    )
+                    if tc.get("id"):
+                        bucket["id"] = tc["id"]
+                    fn = tc.get("function") or {}
+                    if fn.get("name"):
+                        bucket["name"] = fn["name"]
+                    if fn.get("arguments"):
+                        bucket["arguments"] += fn["arguments"]
+
+            usage = obj.get("usage")
+            cost = obj.get("cost")
+            if usage or cost:
+                last_meta = {"usage": usage, "cost": cost}
+
+    if last_model:
+        last_meta["model"] = last_model
+    if tool_calls_accum:
+        last_meta["tool_calls"] = [tool_calls_accum[i] for i in sorted(tool_calls_accum)]
+    if last_meta:
+        yield last_meta

{meshapi_code-0.2.1 → meshapi_code-0.3.0}/src/meshapi/commands.py

@@ -4,7 +4,9 @@ from pathlib import Path
 from rich.panel import Panel
 
 from .config import save_config
+from .permissions import LABELS, Mode, from_str
 from .render import console, fmt_usd
+from .tools import build_system_prompt
 
 ROUTES = {"cheapest", "fastest", "balanced"}
 
@@ -19,7 +21,7 @@ def handle_command(cmd: str, state: dict) -> bool:
         return False
 
     if name == "/clear":
-        state["messages"] = [{"role": "system", "content": state["cfg"]["system"]}]
+        state["messages"] = [{"role": "system", "content": build_system_prompt(state["cfg"])}]
         state["session_cost"] = 0.0
         console.print("[dim]Conversation cleared.[/dim]")
 
@@ -56,7 +58,7 @@ def handle_command(cmd: str, state: dict) -> bool:
     elif name == "/system":
         if arg:
             state["cfg"]["system"] = arg
-            state["messages"] = [{"role": "system", "content": arg}]
+            state["messages"] = [{"role": "system", "content": build_system_prompt(state["cfg"])}]
             console.print("[dim]System prompt updated and conversation reset.[/dim]")
         else:
             console.print(f"[dim]{state['cfg']['system']}[/dim]")
@@ -64,12 +66,24 @@ def handle_command(cmd: str, state: dict) -> bool:
     elif name == "/cost":
         console.print(f"[dim]Session spend: {fmt_usd(state.get('session_cost', 0))}[/dim]")
 
+    elif name == "/mode":
+        if not arg:
+            cur = state.get("mode", Mode.ASK)
+            console.print(f"[dim]Current mode: {LABELS[cur]} ({cur.value})[/dim]")
+        else:
+            try:
+                state["mode"] = from_str(arg)
+                console.print(f"[dim]Mode set to {LABELS[state['mode']]}[/dim]")
+            except ValueError as e:
+                console.print(f"[red]{e}[/red]")
+
     elif name == "/help":
         console.print(Panel.fit(
             "/exit             end session\n"
             "/clear            reset conversation\n"
             "/model <name>     switch model (e.g. anthropic/claude-sonnet-4.5)\n"
             "/route <mode>     cheapest|fastest|balanced|default\n"
+            "/mode <perm>      ask|bypass|none  (or shift+tab to cycle)\n"
             "/file <path>      add file to context\n"
             "/system <txt>     set system prompt\n"
             "/cost             show session spend\n"

meshapi_code-0.3.0/src/meshapi/permissions.py

@@ -0,0 +1,35 @@
+"""Permission modes for tool calls — cycle with Shift+Tab."""
+from enum import Enum
+
+
+class Mode(Enum):
+    ASK = "ask"        # prompt for each tool call (default — safest)
+    BYPASS = "bypass"  # auto-execute without asking (fast — like `--yolo`)
+    NONE = "none"      # don't expose tools to the model at all (read-only chat)
+
+
+ORDER = [Mode.ASK, Mode.BYPASS, Mode.NONE]
+
+LABELS = {
+    Mode.ASK: "approve each",
+    Mode.BYPASS: "bypass perms",
+    Mode.NONE: "no access",
+}
+
+HINTS = {
+    Mode.ASK: "model can request file/shell ops; you confirm each one",
+    Mode.BYPASS: "model executes file/shell ops automatically — be careful",
+    Mode.NONE: "chat only — model has no filesystem or shell access",
+}
+
+
+def next_mode(m: Mode) -> Mode:
+    return ORDER[(ORDER.index(m) + 1) % len(ORDER)]
+
+
+def from_str(s: str) -> Mode:
+    s = s.strip().lower()
+    for m in Mode:
+        if m.value == s:
+            return m
+    raise ValueError(f"unknown mode: {s} (try {', '.join(m.value for m in Mode)})")

meshapi_code-0.3.0/src/meshapi/tools.py

@@ -0,0 +1,129 @@
+"""Tool definitions sent to the model + local executors."""
+import subprocess
+from pathlib import Path
+
+
+def build_system_prompt(cfg: dict) -> str:
+    """Append working-dir + tool guidance to the user's base system prompt.
+
+    Naming tools in prose (read_file/write_file/run_bash) makes Anthropic
+    models drop into XML tool-use mode and emit `<function_calls>` as
+    text — keep this section deliberately tool-name-free.
+    """
+    base = cfg.get("system") or ""
+    cwd = str(Path.cwd())
+    return (
+        f"{base}\n\n"
+        f"Working directory: {cwd}\n"
+        "Resolve any relative path the user gives against this working "
+        "directory. When you create or edit files without an explicit "
+        "absolute path, place them inside this working directory. Use "
+        "the available tools to inspect and modify the filesystem and "
+        "run shell commands — do not ask the user to run commands."
+    )
+
+# OpenAI-compatible tool spec — Mesh API forwards these to the underlying provider.
+TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "read_file",
+            "description": "Read a file from the user's filesystem and return its contents.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "Path to the file (absolute, or relative to the cwd)",
+                    }
+                },
+                "required": ["path"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "write_file",
+            "description": "Create or overwrite a file with the given content. Parent directories are created if missing.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "path": {"type": "string", "description": "File path to write"},
+                    "content": {"type": "string", "description": "Full file contents"},
+                },
+                "required": ["path", "content"],
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "run_bash",
+            "description": "Run a shell command (zsh/bash) and return combined stdout+stderr plus exit code. Times out at 60s.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "command": {"type": "string", "description": "The shell command to run"}
+                },
+                "required": ["command"],
+            },
+        },
+    },
+]
+
+OUTPUT_LIMIT = 8000
+
+
+def execute(name: str, arguments: dict) -> str:
+    """Run a tool locally and return a string result for the model."""
+    if name == "read_file":
+        try:
+            return Path(arguments["path"]).expanduser().read_text()
+        except Exception as e:
+            return f"Error: {e}"
+
+    if name == "write_file":
+        try:
+            p = Path(arguments["path"]).expanduser()
+            p.parent.mkdir(parents=True, exist_ok=True)
+            content = arguments["content"]
+            p.write_text(content)
+            return f"OK — wrote {len(content)} chars to {p}"
+        except Exception as e:
+            return f"Error: {e}"
+
+    if name == "run_bash":
+        try:
+            r = subprocess.run(
+                arguments["command"],
+                shell=True,
+                capture_output=True,
+                text=True,
+                timeout=60,
+                cwd=str(Path.cwd()),
+            )
+            out = (r.stdout or "") + (r.stderr or "")
+            tail = "...[truncated]" if len(out) > OUTPUT_LIMIT else ""
+            return f"{out[:OUTPUT_LIMIT]}{tail}\n[exit {r.returncode}]"
+        except subprocess.TimeoutExpired:
+            return "Error: command timed out after 60s"
+        except Exception as e:
+            return f"Error: {e}"
+
+    return f"Error: unknown tool `{name}`"
+
+
+def summarize_call(name: str, arguments: dict) -> str:
+    """One-line summary used in the approval prompt and progress log."""
+    if name == "read_file":
+        return f"read_file: {arguments.get('path')}"
+    if name == "write_file":
+        n = len(arguments.get("content", ""))
+        return f"write_file: {arguments.get('path')} ({n} chars)"
+    if name == "run_bash":
+        cmd = arguments.get("command", "")
+        if len(cmd) > 200:
+            cmd = cmd[:200] + "…"
+        return f"run_bash: {cmd}"
+    return f"{name}({arguments})"

meshapi_code-0.2.1/src/meshapi/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.1"

meshapi_code-0.2.1/src/meshapi/cli.py

@@ -1,146 +0,0 @@
-"""meshapi — terminal chat REPL for Mesh API."""
-import argparse
-import sys
-from pathlib import Path
-
-import httpx
-from prompt_toolkit import PromptSession
-from prompt_toolkit.history import FileHistory
-from prompt_toolkit.styles import Style
-from rich.text import Text
-
-from . import __version__
-from .client import stream_chat
-from .commands import handle_command
-from .config import CONFIG_FILE, HISTORY_FILE, load_config
-from .render import BRAND, BRAND_BG, BRAND_BG_FG, BRAND_DIM, console, fmt_usd, pretty_cwd, render_stream
-
-# ANSI Shadow figlet font
-MESH_LOGO_LINES = [
-    "███╗   ███╗███████╗███████╗██╗  ██╗",
-    "████╗ ████║██╔════╝██╔════╝██║  ██║",
-    "██╔████╔██║█████╗  ███████╗███████║",
-    "██║╚██╔╝██║██╔══╝  ╚════██║██╔══██║",
-    "██║ ╚═╝ ██║███████╗███████║██║  ██║",
-    "╚═╝     ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝",
-]
-LOGO_WIDTH = 35  # chars per line
-LOGO_GUTTER = 3  # spaces between logo and info column
-
-
-def parse_args(argv=None) -> argparse.Namespace:
-    p = argparse.ArgumentParser(prog="meshapi", description="Terminal chat for Mesh API")
-    p.add_argument("--version", action="version", version=f"meshapi {__version__}")
-    p.add_argument("--model", help="Override model for this session (e.g. openai/gpt-4o-mini)")
-    p.add_argument("--route", choices=["cheapest", "fastest", "balanced"], help="Routing mode")
-    return p.parse_args(argv)
-
-
-def main() -> None:
-    args = parse_args()
-    cfg = load_config()
-    if args.model:
-        cfg["model"] = args.model
-    if args.route:
-        cfg["route"] = args.route
-
-    if not cfg["api_key"]:
-        console.print(
-            "[red]No API key found. Set MESHAPI_API_KEY env var or edit "
-            f"{CONFIG_FILE}[/red]"
-        )
-        sys.exit(1)
-
-    state = {
-        "cfg": cfg,
-        "messages": [{"role": "system", "content": cfg["system"]}],
-        "session_cost": 0.0,
-    }
-
-    session = PromptSession(history=FileHistory(str(HISTORY_FILE)))
-
-    info_per_line: list = [
-        None,
-        None,
-        Text.from_markup(f"[bold {BRAND}]✦  meshapi {__version__}[/bold {BRAND}]"),
-        Text.from_markup(f"cwd:   [{BRAND}]{pretty_cwd()}[/{BRAND}]"),
-        Text.from_markup(f"model: [bold {BRAND}]{cfg['model']}[/bold {BRAND}]"),
-        Text.from_markup(f"route: [{BRAND}]{cfg.get('route') or 'default'}[/{BRAND}]"),
-    ]
-
-    console.print()  # top gap so banner doesn't crowd the shell prompt
-    for i, logo_line in enumerate(MESH_LOGO_LINES):
-        line = Text()
-        line.append(logo_line, style=BRAND)
-        info = info_per_line[i] if i < len(info_per_line) else None
-        if info is not None:
-            pad = max(0, LOGO_WIDTH - len(logo_line))
-            line.append(" " * (pad + LOGO_GUTTER))
-            line.append(info)
-        console.print(line)
-    console.print()
-    console.print("type /help for commands, /exit to quit", style=BRAND_DIM)
-    console.print()  # bottom gap before the first prompt rule
-
-    while True:
-        try:
-            console.rule(
-                title=f"[{BRAND_DIM}]{Path.cwd().name}[/{BRAND_DIM}]",
-                align="right",
-                style=BRAND_DIM,
-                characters="─",
-            )
-            user_input = session.prompt(
-                "› ",
-                style=Style.from_dict({
-                    "prompt": f"bold fg:{BRAND} bg:{BRAND_BG}",
-                    "": f"fg:{BRAND_BG_FG} bg:{BRAND_BG}",
-                }),
-            )
-            console.rule(style=BRAND_DIM, characters="─")
-        except (KeyboardInterrupt, EOFError):
-            console.print("\n[dim]bye[/dim]")
-            break
-
-        if not user_input.strip():
-            continue
-        if user_input.startswith("/"):
-            if not handle_command(user_input, state):
-                break
-            continue
-
-        state["messages"].append({"role": "user", "content": user_input})
-        console.print()
-        try:
-            reply, meta = render_stream(stream_chat(state["messages"], state["cfg"]))
-            state["messages"].append({"role": "assistant", "content": reply})
-
-            cost = meta.get("cost")
-            if cost is not None:
-                try:
-                    state["session_cost"] += float(cost)
-                except (TypeError, ValueError):
-                    pass
-            usage = meta.get("usage") or {}
-            model = meta.get("model") or state["cfg"]["model"]
-            elapsed = meta.get("elapsed", 0.0)
-            prompt_t = usage.get("prompt_tokens", "?")
-            completion_t = usage.get("completion_tokens", "?")
-            cost_str = fmt_usd(cost) if cost is not None else "—"
-            console.rule(style=BRAND_DIM, characters="─")
-            console.print(
-                f"[dim]{model}  •  {prompt_t}→{completion_t} tok  •  {cost_str}  •  "
-                f"session {fmt_usd(state['session_cost'])}  •  {elapsed:.1f}s[/dim]"
-            )
-        except httpx.HTTPStatusError as e:
-            console.rule(style="dim red", characters="─")
-            console.print(f"[red]API error {e.response.status_code}: {e.response.text}[/red]")
-            state["messages"].pop()
-        except Exception as e:
-            console.rule(style="dim red", characters="─")
-            console.print(f"[red]Error: {e}[/red]")
-            state["messages"].pop()
-
-
-if __name__ == "__main__":
-    main()

meshapi_code-0.2.1/src/meshapi/client.py

@@ -1,58 +0,0 @@
-"""Streaming OpenAI-compatible HTTP client for Mesh API."""
-import json
-from typing import Iterable
-
-import httpx
-
-
-def stream_chat(messages: list, cfg: dict) -> Iterable:
-    """Yield content deltas, then a final {'usage':..., 'cost':...} dict.
-
-    Mesh API is OpenAI-compatible but adds `cost` to the final SSE chunk.
-    """
-    url = f"{cfg['base_url']}/chat/completions"
-    headers = {
-        "Authorization": f"Bearer {cfg['api_key']}",
-        "Content-Type": "application/json",
-    }
-    payload: dict = {
-        "model": cfg["model"],
-        "messages": messages,
-        "stream": True,
-    }
-    if cfg.get("route"):
-        payload["route"] = cfg["route"]
-
-    last_meta: dict = {}
-    last_model: str = ""
-    with httpx.stream("POST", url, json=payload, headers=headers, timeout=120) as r:
-        r.raise_for_status()
-        for line in r.iter_lines():
-            if not line or not line.startswith("data: "):
-                continue
-            data = line[6:]
-            if data.strip() == "[DONE]":
-                break
-            try:
-                obj = json.loads(data)
-            except json.JSONDecodeError:
-                continue
-
-            if obj.get("model"):
-                last_model = obj["model"]
-
-            choices = obj.get("choices") or []
-            if choices:
-                delta = choices[0].get("delta", {}).get("content")
-                if delta:
-                    yield delta
-
-            usage = obj.get("usage")
-            cost = obj.get("cost")
-            if usage or cost:
-                last_meta = {"usage": usage, "cost": cost}
-
-    if last_model:
-        last_meta["model"] = last_model
-    if last_meta:
-        yield last_meta