meshapi-code 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

meshapi/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.1"
+__version__ = "0.3.1"

meshapi/cli.py

@@ -1,11 +1,14 @@
 """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
 
@@ -13,7 +16,11 @@ 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
+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 = [
@@ -27,15 +34,96 @@ 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()
@@ -53,34 +141,35 @@ def main() -> None:
 
     state = {
         "cfg": cfg,
-        "messages": [{"role": "system", "content": cfg["system"]}],
+        "messages": [{"role": "system", "content": build_system_prompt(cfg)}],
         "session_cost": 0.0,
+        "mode": from_str(args.mode),
     }
 
-    session = PromptSession(history=FileHistory(str(HISTORY_FILE)))
+    kb = KeyBindings()
 
-    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}]"),
-    ]
+    @kb.add("s-tab")  # Shift+Tab
+    def _(event):
+        state["mode"] = next_mode(state["mode"])
+        event.app.invalidate()
 
-    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
+    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:
@@ -95,6 +184,7 @@ def main() -> None:
                 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="─")
@@ -111,26 +201,44 @@ def main() -> None:
 
         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:
-            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 "—"
+            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]{model}  •  {prompt_t}→{completion_t} tok  •  {cost_str}  •  "
-                f"session {fmt_usd(state['session_cost'])}  •  {elapsed:.1f}s[/dim]"
+                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="─")

meshapi/client.py

@@ -1,14 +1,21 @@
 """Streaming OpenAI-compatible HTTP client for Mesh API."""
 import json
-from typing import Iterable
+from typing import Iterable, Optional
 
 import httpx
 
 
-def stream_chat(messages: list, cfg: dict) -> Iterable:
-    """Yield content deltas, then a final {'usage':..., 'cost':...} dict.
+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 but adds `cost` to the final SSE chunk.
+    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 = {
@@ -22,9 +29,14 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
     }
     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():
@@ -43,9 +55,24 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
 
             choices = obj.get("choices") or []
             if choices:
-                delta = choices[0].get("delta", {}).get("content")
-                if delta:
-                    yield delta
+                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")
@@ -54,5 +81,7 @@ def stream_chat(messages: list, cfg: dict) -> Iterable:
 
     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/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/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/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.3.1.dist-info/METADATA

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: meshapi-code
+Version: 0.3.1
+Summary: Terminal chat for Mesh API — OpenAI-compatible LLM gateway
+Project-URL: Homepage, https://meshapi.ai
+Project-URL: Documentation, https://docs.meshapi.ai
+Project-URL: Repository, https://github.com/aifiesta/meshapi-code
+Author: Mesh API
+License: MIT
+License-File: LICENSE
+Keywords: anthropic,chat,cli,gateway,llm,mesh,openai
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: rich>=13.7
+Description-Content-Type: text/markdown
+
+# meshapi-code
+
+Terminal chat REPL for [Mesh API](https://meshapi.ai) — one OpenAI-compatible key, 300+ models. Streaming responses, live markdown, file/shell tool calls with approval, real-time cost.
+
+```
+$ meshapi
+███╗   ███╗███████╗███████╗██╗  ██╗   ✦  meshapi 0.3.0
+████╗ ████║██╔════╝██╔════╝██║  ██║   cwd:   ~/code/myproj
+██╔████╔██║█████╗  ███████╗███████║   model: anthropic/claude-sonnet-4.5
+██║╚██╔╝██║██╔══╝  ╚════██║██╔══██║   route: cheapest
+██║ ╚═╝ ██║███████╗███████║██║  ██║
+╚═╝     ╚═╝╚══════╝╚══════╝╚═╝  ╚═╝
+type /help for commands, /exit to quit
+
+› add a healthcheck endpoint to server.py and run the tests
+… streamed markdown reply …
+⚙ approve tool call?  write_file: server.py (1240 chars)   y/n › y
+⚙ approve tool call?  run_bash: pytest -q                  y/n › y
+   anthropic/claude-sonnet-4.5  •  942→318 tok  •  $0.001234  •  session $0.001234
+   mode: approve each   model can request file/shell ops; you confirm each one   shift+tab to cycle
+```
+
+## Install
+
+```bash
+pipx install meshapi-code           # recommended
+uv tool install meshapi-code        # if you use uv
+pip install meshapi-code            # plain pip
+```
+
+PyPI package is `meshapi-code`; the command on your `$PATH` is `meshapi` (same split Claude Code uses: `@anthropic-ai/claude-code` → `claude`).
+
+```bash
+export MESHAPI_API_KEY=rsk_your_key_here
+meshapi
+```
+
+Get a key at [meshapi.ai](https://meshapi.ai).
+
+## What it does
+
+- **Streaming completions** with live markdown rendering (`rich`).
+- **Real cost per turn** — Mesh returns `cost` in the SSE tail; we surface it after every reply and accumulate `session $…`.
+- **Tool calling** — the model can read files, write files, and run shell commands in the launch directory. Off by default behind an approval prompt; toggle with one key.
+- **Permission modes** — `approve each` (default), `bypass perms` (auto-execute, for trusted prompts), or `no access` (chat only). Cycle live with **Shift+Tab**.
+- **Mid-session switching** — `/model openai/gpt-4o-mini`, `/route cheapest`, `/mode bypass`.
+- **Smart routing** — `/route cheapest|fastest|balanced` hands model selection to Mesh's gateway, so you don't have to.
+- **Persistent input history** — up-arrow recalls past prompts across sessions.
+- **Config + env-var override** — `~/.meshapi/config.json`, `MESHAPI_API_KEY`.
+
+## Tool calling
+
+When tools are enabled, the model can call:
+
+| Tool | What it does |
+|---|---|
+| `read_file` | Read a file from the working directory (or absolute path). |
+| `write_file` | Create or overwrite a file. Parent dirs are created. |
+| `run_bash` | Run a shell command in the working directory. 60s timeout, 8000-char output cap. |
+
+The launch CWD is baked into the system prompt, so relative paths the model produces resolve where you'd expect. Three permission modes, cycled live with Shift+Tab or set with `--mode` / `/mode`:
+
+- **`ask`** (default) — every tool call requires a `y/n` confirmation. Safe.
+- **`bypass`** — the model auto-executes. Fast, like Claude Code's `--dangerously-skip-permissions`. Use only when you trust the prompt.
+- **`none`** — tools aren't sent to the model at all. Pure chat.
+
+```bash
+meshapi --mode bypass     # start in auto-execute mode
+meshapi                   # default ask; press Shift+Tab to cycle
+```
+
+## Slash commands
+
+| Command | What it does |
+|---|---|
+| `/help` | List commands |
+| `/model <name>` | Switch model (e.g. `anthropic/claude-sonnet-4.5`, `openai/gpt-4o-mini`) |
+| `/route <mode>` | `cheapest`, `fastest`, `balanced`, or `default` |
+| `/mode <perm>` | `ask`, `bypass`, or `none` (Shift+Tab also cycles) |
+| `/file <path>` | Inject a file into the conversation |
+| `/system <text>` | Replace system prompt and reset chat |
+| `/cost` | Show cumulative session spend |
+| `/clear` | Reset conversation |
+| `/exit` | Quit |
+
+## Config
+
+`~/.meshapi/config.json`:
+
+```json
+{
+  "base_url": "https://api.meshapi.ai/v1",
+  "model": "anthropic/claude-sonnet-4.5",
+  "system": "You are a helpful coding assistant. Be concise.",
+  "route": null
+}
+```
+
+The API key is read from `MESHAPI_API_KEY` (preferred) or stored in the same file. Input history lives at `~/.meshapi/history`.
+
+## About Mesh API
+
+[Mesh API](https://meshapi.ai) is a unified LLM gateway: one API key, 300+ models from OpenAI, Anthropic, Google, Meta, Mistral, DeepSeek, Alibaba, and more. It's OpenAI-compatible — change the model name in your request, leave everything else alone.
+
+- **Zero platform fees for 12 months.** You only pay for tokens.
+- **Smart auto routing.** `route: cheapest|fastest|balanced` and the gateway picks for you.
+- **Automatic failover.** If a provider goes down, your request routes to another. Your users won't know.
+- **Highest rate limits.** Capacity is pooled across providers, so you hit ceilings later than going direct.
+- **Zero data retention.** Prompts and completions pass through; we don't store them.
+- **Multi-currency billing.** USD and INR (for India-based teams) at launch.
+- **Ready-made workflows.** Pre-built prompt templates you can plug into any model.
+- **Full observability.** Every request, token, cost, error, and model usage tracked in real time. Per-key spending limits and usage controls.
+
+Built by the founders of [TagMango](https://tagmango.com) (YC W20) and [AI Fiesta](https://aifiesta.ai) (1M+ users across India). We got tired of managing five different provider dashboards ourselves, so we built this.
+
+## Why this CLI exists
+
+Any generic OpenAI-compatible chat CLI talks to Mesh. `meshapi` adds three things a generic CLI can't: (1) the gateway-only `cost` field shown after every turn, (2) `/route` controls that drive Mesh's gateway-side model selection, and (3) tool calling that resolves paths against the directory you launched from.
+
+## Roadmap
+
+- ✅ v0.3 — tool calling, ask/bypass/none permission modes, CWD-aware system prompt
+- v0.4 — repo-aware mode, diff apply, `/cd` to change working dir mid-session
+- v0.5 — `npm i -g meshapi-code` (Node port using `ink` + `chalk`), Homebrew tap, curl|sh installer at `meshapi.ai/install.sh`
+
+## License
+
+MIT

meshapi_code-0.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+meshapi/__init__.py,sha256=r4xAFihOf72W9TD-lpMi6ntWSTKTP2SlzKP1ytkjRbI,22
+meshapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+meshapi/cli.py,sha256=d1-WSXTUiwKUbFhn6sOzUe_Gb9I8CxbsMdFXVX_k_YU,9777
+meshapi/client.py,sha256=-kkPKMsl98wX_N0X6Rr8GNygJH4HSlrWloiWlhQuwgU,2824
+meshapi/commands.py,sha256=fc_qnTa_oZgn5CRQ7GrpUm1Zclmat4McLdEV5YX5Wvg,3662
+meshapi/config.py,sha256=DcqOjZtAufuSDg2vDs0lsBynRjThL_8znLOl_Y2_PN4,1159
+meshapi/permissions.py,sha256=NOZy7DyP05HyuIoYYO3-YT_U0wnU4wg_syfxDqh3Oz8,1016
+meshapi/render.py,sha256=z7ggnk8BqwcGK3tJm5PunEnROiVQmDWAD4hvJeg9gF4,4251
+meshapi/tools.py,sha256=BIy_kJrIuY0RXDfTSOo8MrcjuIKR7LR8PYl36JONY-g,4578
+meshapi_code-0.3.1.dist-info/METADATA,sha256=XcW8UomUza-an5a9EbajcLZYXaLRGJNWGQU0upPrdGY,7518
+meshapi_code-0.3.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+meshapi_code-0.3.1.dist-info/entry_points.txt,sha256=ZCXZ_SgrhWIQEHSjAXz0pUlyGbIQKZ68vp_Cg1Y0rME,45
+meshapi_code-0.3.1.dist-info/licenses/LICENSE,sha256=oALrQSPnF5cbhoBcSv6uDDsPUGl7q5Y2AL-dJ--wzt8,1065
+meshapi_code-0.3.1.dist-info/RECORD,,

meshapi_code-0.2.1.dist-info/METADATA

@@ -1,112 +0,0 @@
-Metadata-Version: 2.4
-Name: meshapi-code
-Version: 0.2.1
-Summary: Terminal chat for Mesh API — OpenAI-compatible LLM gateway
-Project-URL: Homepage, https://meshapi.ai
-Project-URL: Documentation, https://docs.meshapi.ai
-Project-URL: Repository, https://github.com/aifiesta/meshapi-code
-Author: Mesh API
-License: MIT
-License-File: LICENSE
-Keywords: anthropic,chat,cli,gateway,llm,mesh,openai
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Topic :: Software Development
-Requires-Python: >=3.10
-Requires-Dist: httpx>=0.27
-Requires-Dist: prompt-toolkit>=3.0
-Requires-Dist: rich>=13.7
-Description-Content-Type: text/markdown
-
-# meshapi-code
-
-Terminal chat for [Mesh API](https://meshapi.ai) — the OpenAI-compatible LLM gateway. Streaming responses, live markdown, slash commands, real-time cost.
-
-```
-$ meshapi
-╭───────────────────────────────╮
-│ meshapi 0.1.0                 │
-│ model: anthropic/claude-…     │
-│ route: default                │
-╰───────────────────────────────╯
-you > how do I parse SSE in python
-… streamed markdown reply …
-   142 → 318 tok  •  $0.001234  •  session $0.001234
-```
-
-## Install
-
-```bash
-pipx install meshapi-code           # recommended
-uv tool install meshapi-code        # if you use uv
-pip install meshapi-code            # plain pip
-```
-
-The PyPI package is `meshapi-code`; the command on your `$PATH` is `meshapi`.
-
-Then:
-
-```bash
-export MESHAPI_API_KEY=rsk_your_key_here
-meshapi
-```
-
-Get a key at [meshapi.ai](https://meshapi.ai).
-
-## What it does
-
-- **Streaming completions** with live markdown rendering (`rich`)
-- **Real cost per turn** — Mesh API returns `cost` in the SSE tail; we show it
-- **Slash commands** — `/model`, `/route`, `/file`, `/system`, `/cost`, `/clear`
-- **Mid-session model switching** — `/model openai/gpt-4o-mini`
-- **Smart routing** — `/route cheapest` lets the gateway pick (Mesh-specific)
-- **Persistent input history** — up-arrow recalls past prompts
-- **Config + env-var override** — `~/.meshapi/config.json`, `MESHAPI_API_KEY`
-
-## Slash commands
-
-| Command | What it does |
-|---|---|
-| `/help` | List commands |
-| `/model <name>` | Switch model (e.g. `anthropic/claude-sonnet-4.5`) |
-| `/route <mode>` | `cheapest`, `fastest`, `balanced`, or `default` |
-| `/file <path>` | Inject a file into the conversation |
-| `/system <text>` | Replace system prompt and reset chat |
-| `/cost` | Show cumulative session spend |
-| `/clear` | Reset conversation |
-| `/exit` | Quit |
-
-## Config
-
-`~/.meshapi/config.json`:
-
-```json
-{
-  "base_url": "https://api.meshapi.ai/v1",
-  "model": "anthropic/claude-sonnet-4.5",
-  "system": "You are a helpful coding assistant. Be concise.",
-  "route": null
-}
-```
-
-The API key is read from `MESHAPI_API_KEY` (preferred) or stored in the same file.
-
-## Why it exists
-
-Mesh API is OpenAI-compatible, so any generic chat CLI works against it. `meshapi` adds two things a generic CLI can't: (1) the gateway-only `cost` field shown after every turn, and (2) routing controls (`/route cheapest`) that hit Mesh's gateway-side model selection.
-
-## Roadmap
-
-- v0.2 — tool calling, repo-aware mode, diff apply, `npm i -g meshapi-code`
-- v0.3 — Homebrew tap, curl|sh installer at `meshapi.ai/install.sh`
-
-## License
-
-MIT

meshapi_code-0.2.1.dist-info/RECORD

@@ -1,12 +0,0 @@
-meshapi/__init__.py,sha256=HfjVOrpTnmZ-xVFCYSVmX50EXaBQeJteUHG-PD6iQs8,22
-meshapi/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
-meshapi/cli.py,sha256=fsdAVM9dPjlJZ_ECMWSoiWGN04HhfF0ZBk76CaOljMQ,5758
-meshapi/client.py,sha256=ZJ9ecsMjE8T0UlksacNwoIEKznsOa4W2bbnSMjIGI6E,1708
-meshapi/commands.py,sha256=0ZiIh9n94f6ix-hH3u4v3gW7N8sLSWsPv9sdDPEUbg0,3040
-meshapi/config.py,sha256=DcqOjZtAufuSDg2vDs0lsBynRjThL_8znLOl_Y2_PN4,1159
-meshapi/render.py,sha256=z7ggnk8BqwcGK3tJm5PunEnROiVQmDWAD4hvJeg9gF4,4251
-meshapi_code-0.2.1.dist-info/METADATA,sha256=jIqW6c1RvKtiABmU_7Aj2qSvFldn_4FEAqn-FbT82VM,3765
-meshapi_code-0.2.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-meshapi_code-0.2.1.dist-info/entry_points.txt,sha256=ZCXZ_SgrhWIQEHSjAXz0pUlyGbIQKZ68vp_Cg1Y0rME,45
-meshapi_code-0.2.1.dist-info/licenses/LICENSE,sha256=oALrQSPnF5cbhoBcSv6uDDsPUGl7q5Y2AL-dJ--wzt8,1065
-meshapi_code-0.2.1.dist-info/RECORD,,