mycode-cli 0.12.0__tar.gz → 0.13.0__tar.gz

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: mycode-cli
-Version: 0.12.0
+Version: 0.13.0
 Summary: Minimal coding agent CLI and web UI built on mycode-sdk.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -21,9 +21,13 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development
 Requires-Python: >=3.12
+Requires-Dist: beautifulsoup4>=4.15.0
 Requires-Dist: fastapi>=0.139.0
-Requires-Dist: mycode-sdk==0.12.0
+Requires-Dist: httpx2>=2.10.0
+Requires-Dist: markdownify>=1.2.3
+Requires-Dist: mycode-sdk==0.13.0
 Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pydantic>=2.13.4
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=15.0.0
 Requires-Dist: typer>=0.26.8

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/hatch_build.py

@@ -27,12 +27,9 @@ def _build_web_assets(project_root: Path) -> None:
     static_dir = project_root / "src" / "mycode_cli" / "server" / "static"
 
     if not (web_dir / "package.json").is_file():
-        if static_dir.is_dir():
+        if (static_dir / "index.html").is_file():
             return
-        raise RuntimeError(
-            f"web sources not found at {web_dir}; the web/ submodule is not "
-            "initialized. Run: git submodule update --init --recursive"
-        )
+        raise RuntimeError(f"web sources not found at {web_dir} and built assets not found at {static_dir}")
 
     _run_pnpm(["install", "--frozen-lockfile"], cwd=web_dir)
     _run_pnpm(["build"], cwd=web_dir)
@@ -48,8 +45,7 @@ def _build_web_assets(project_root: Path) -> None:
 class CustomBuildHook(BuildHookInterface[Any]):
     def initialize(self, version: str, build_data: dict[str, Any]) -> None:
         del build_data
-        # Editable installs (uv sync) don't bundle web assets, so skip the build
-        # and its web/ submodule + pnpm requirements. Wheel/sdist builds use "standard".
+        # Editable installs don't bundle web assets.
         if version == "editable":
             return
         _build_web_assets(Path(self.root))

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-cli"
-version = "0.12.0"
+version = "0.13.0"
 description = "Minimal coding agent CLI and web UI built on mycode-sdk."
 readme = "README.md"
 requires-python = ">=3.12"
@@ -26,13 +26,17 @@ classifiers = [
 ]
 keywords = ["agent", "cli", "llm", "coding-agent", "fastapi"]
 dependencies = [
-    "mycode-sdk==0.12.0",
+    "mycode-sdk==0.13.0",
     "fastapi>=0.139.0",
     "uvicorn[standard]>=0.51.0",
     "rich>=15.0.0",
     "prompt-toolkit>=3.0.52",
+    "pydantic>=2.13.4",
     "typer>=0.26.8",
     "pyyaml>=6.0.3",
+    "httpx2>=2.10.0",
+    "beautifulsoup4>=4.15.0",
+    "markdownify>=1.2.3",
 ]
 
 [project.scripts]

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/config.py

@@ -41,6 +41,13 @@ _EFFORT_OFF_ALIASES = frozenset({"off", "disabled"})
 
 PermissionLevel = Literal["readonly", "safe", "standard", "yolo"]
 PermissionMode = Literal["ask", "deny"]
+WebFetchProvider = Literal["local", "tavily", "exa"]
+WebSearchProvider = Literal["off", "tavily", "exa"]
+
+WEB_PROVIDER_ENV_VARS = {
+    "tavily": "TAVILY_API_KEY",
+    "exa": "EXA_API_KEY",
+}
 
 
 @dataclass(frozen=True)
@@ -71,6 +78,20 @@ class PermissionConfig:
     mode: PermissionMode = "ask"
 
 
+@dataclass(frozen=True)
+class WebProviderConfig:
+    api_key: str | None = None
+    api_key_env_var: str | None = None
+
+
+@dataclass(frozen=True)
+class WebConfig:
+    fetch: WebFetchProvider = "local"
+    search: WebSearchProvider = "off"
+    tavily: WebProviderConfig = field(default_factory=WebProviderConfig)
+    exa: WebProviderConfig = field(default_factory=WebProviderConfig)
+
+
 @dataclass(frozen=True)
 class Settings:
     providers: dict[str, ProviderConfig]
@@ -81,6 +102,7 @@ class Settings:
     project: str
     compact_threshold: float | None = None
     permission: PermissionConfig = field(default_factory=PermissionConfig)
+    web: WebConfig = field(default_factory=WebConfig)
     config_paths: list[str] = field(default_factory=list)
 
 
@@ -286,6 +308,11 @@ def _clean_config_layer(data: Any) -> dict[str, Any]:
     if data.get("permission") is not None:
         out["permission"] = _validate_permission_config(data["permission"])
 
+    if data.get("web") is not None:
+        web = _validate_web_config(data["web"])
+        if web:
+            out["web"] = web
+
     raw_providers = data.get("providers")
     if raw_providers is not None:
         if not isinstance(raw_providers, dict):
@@ -351,6 +378,36 @@ def _validate_permission_config(raw: Any) -> PermissionLevel | dict[str, Any]:
     return out
 
 
+def _validate_web_config(raw: Any) -> dict[str, Any]:
+    if not isinstance(raw, dict):
+        raise ValueError("web must be an object")
+
+    out: dict[str, Any] = {}
+    options = {
+        "fetch": ("local", "tavily", "exa"),
+        "search": ("off", "tavily", "exa"),
+    }
+    for key, supported in options.items():
+        if key not in raw:
+            continue
+        value = raw[key]
+        if value not in supported:
+            raise ValueError(f"web.{key} must be one of: {', '.join(supported)}")
+        out[key] = value
+
+    for provider in ("tavily", "exa"):
+        if provider not in raw:
+            continue
+        entry = raw[provider]
+        if not isinstance(entry, dict):
+            raise ValueError(f"web.{provider} must be an object")
+        api_key = _optional_config_string(entry, "api_key", f"web.{provider}.api_key")
+        if api_key:
+            out[provider] = {"api_key": api_key}
+
+    return out
+
+
 def _validate_provider_config(name: str, raw: Any) -> dict[str, Any]:
     if not isinstance(raw, dict):
         raise ValueError(f"provider {name!r} must be an object")
@@ -434,6 +491,7 @@ def get_settings(cwd: str | None = None) -> Settings:
     default_model: str | None = None
     compact_threshold: float | None = None
     permission = PermissionConfig()
+    raw_web: dict[str, Any] = {}
     config_paths: list[str] = []
 
     for path in _candidate_config_paths(resolved_cwd, resolved_project):
@@ -482,12 +540,27 @@ def get_settings(cwd: str | None = None) -> Settings:
         if "permission" in data:
             permission = parse_permission(data.get("permission"), permission)
 
+        if data.get("web") is not None:
+            web = _validate_web_config(data["web"])
+            for key in ("fetch", "search"):
+                if key in web:
+                    raw_web[key] = web[key]
+            for provider in ("tavily", "exa"):
+                entry = web.get(provider)
+                if entry:
+                    api_key, api_key_env_var = _parse_config_api_key(entry["api_key"])
+                    raw_web[provider] = {
+                        "api_key": api_key,
+                        "api_key_env_var": api_key_env_var,
+                    }
+
     return Settings(
         providers=_build_providers(raw_providers),
         default_provider=default_provider,
         default_model=default_model,
         compact_threshold=compact_threshold,
         permission=permission,
+        web=_build_web_config(raw_web),
         port=int(os.environ.get("PORT", "8000")),
         cwd=resolved_cwd,
         project=resolved_project,
@@ -562,6 +635,38 @@ def _build_providers(raw_providers: dict[str, dict[str, Any]]) -> dict[str, Prov
     return providers
 
 
+def _build_web_config(raw: dict[str, Any]) -> WebConfig:
+    def provider(name: str) -> WebProviderConfig:
+        entry = raw.get(name)
+        if not isinstance(entry, dict):
+            return WebProviderConfig()
+        return WebProviderConfig(
+            api_key=entry.get("api_key") or None,
+            api_key_env_var=entry.get("api_key_env_var") or None,
+        )
+
+    return WebConfig(
+        fetch=cast(WebFetchProvider, raw.get("fetch") or "local"),
+        search=cast(WebSearchProvider, raw.get("search") or "off"),
+        tavily=provider("tavily"),
+        exa=provider("exa"),
+    )
+
+
+def resolve_web_api_key(web: WebConfig, provider: Literal["tavily", "exa"]) -> str | None:
+    """Resolve a web provider key without requiring one to exist."""
+
+    config = getattr(web, provider)
+    if config.api_key:
+        return config.api_key
+    if config.api_key_env_var:
+        value = (os.environ.get(config.api_key_env_var) or "").strip()
+        if value:
+            return value
+        raise ValueError(f"missing API key env var {config.api_key_env_var!r} referenced by web.{provider}")
+    return (os.environ.get(WEB_PROVIDER_ENV_VARS[provider]) or "").strip() or None
+
+
 def provider_has_api_key(provider: ProviderConfig) -> bool:
     """Return whether a configured provider can authenticate right now."""
 

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/permissions.py

@@ -123,12 +123,23 @@ def classify_tool(
         command = str(ctx.tool_input.get("command") or "").strip()
         return PermissionCheck(_classify_bash(command), command)
 
+    if name == "webfetch":
+        url = str(ctx.tool_input.get("url") or "").strip()
+        return PermissionCheck("standard", url)
+
+    if name == "websearch":
+        query = str(ctx.tool_input.get("query") or "").strip()
+        return PermissionCheck("standard", query)
+
     if name in {"read", "write", "edit"}:
         raw = str(ctx.tool_input.get("path") or "")
         path = resolve_path(raw, cwd=cwd)
         project_path = Path(project).resolve(strict=False)
         preview = raw or str(path)
-        if name == "read" and any(path.is_relative_to(root) for root in skill_roots):
+        if name == "read" and (
+            path.is_relative_to(ctx.tool_output_dir.resolve(strict=False))
+            or any(path.is_relative_to(root) for root in skill_roots)
+        ):
             return PermissionCheck("readonly", preview)
         if not path.is_relative_to(project_path):
             return PermissionCheck("yolo", preview)

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/runtime.py

@@ -3,12 +3,12 @@
 from __future__ import annotations
 
 from mycode.agent import Agent
-from mycode.models import estimate_cost, resolve_model_metadata
 from mycode.session import SessionStore
-from mycode.tools import bash_tool, edit_tool, read_tool, write_tool
 from mycode_cli.config import ResolvedProvider, Settings
 from mycode_cli.permissions import ToolReviewCallback, build_permission_hooks
 from mycode_cli.system_prompt import build_system_prompt
+from mycode_cli.tools import DEFAULT_TOOLS
+from mycode_cli.web_tools import build_web_tools
 
 
 def sum_known_costs(*costs: float | None) -> float | None:
@@ -17,13 +17,10 @@ def sum_known_costs(*costs: float | None) -> float | None:
 
 
 async def load_session_cost(store: SessionStore, session_id: str) -> float | None:
-    """Estimate the session's cumulative USD cost from its raw JSONL timeline.
+    """Load the session's cumulative USD cost from its raw JSONL timeline.
 
-    Every persisted provider request counts: tool loops, compact summaries,
-    and turns discarded by rewind (billed is billed). Each assistant/compact
-    record is priced by its own ``meta.provider``/``meta.model`` through the
-    SDK catalog; an upstream-reported ``reported_cost_usd`` wins. Records
-    without a usable estimate are skipped.
+    Counts persisted costs from tool loops, compact summaries, and turns
+    discarded by rewind. Records without a cost are skipped.
     """
 
     total: float | None = None
@@ -31,12 +28,12 @@ async def load_session_cost(store: SessionStore, session_id: str) -> float | Non
         if message.get("role") not in {"assistant", "compact"}:
             continue
         meta = message.get("meta") or {}
-        usage = meta.get("usage")
-        if not isinstance(usage, dict):
+        cost = meta.get("cost")
+        if not isinstance(cost, dict):
             continue
-        metadata = resolve_model_metadata(provider=str(meta.get("provider") or ""), model=str(meta.get("model") or ""))
-        request_cost = estimate_cost(usage, metadata.cost)
-        total = sum_known_costs(total, request_cost)
+        request_total = cost.get("total")
+        if isinstance(request_total, int | float):
+            total = sum_known_costs(total, float(request_total))
     return total
 
 
@@ -75,6 +72,6 @@ def build_agent(
         compact_threshold=settings.compact_threshold,
         max_turns=max_turns,
         system=build_system_prompt(cwd, settings),
-        tools=[read_tool, write_tool, edit_tool, bash_tool],
+        tools=[*DEFAULT_TOOLS, *build_web_tools(settings.web)],
         hooks=hooks,
     )

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/server/routers/sessions.py

@@ -9,7 +9,6 @@ from fastapi import APIRouter, HTTPException, Query
 from fastapi import Path as PathParam
 
 from mycode.messages import ConversationMessage
-from mycode.models import estimate_cost, resolve_model_metadata
 from mycode_cli.runtime import load_session_cost
 from mycode_cli.server.deps import RunManagerDep, StoreDep, resolve_workspace_cwd
 from mycode_cli.server.schemas import SessionCreateRequest, StatusResponse
@@ -31,29 +30,6 @@ def _redact_document_data(messages: list[ConversationMessage]) -> list[dict[str,
     return redacted
 
 
-def _with_request_costs(messages: list[ConversationMessage]) -> list[ConversationMessage]:
-    """Stamp the response-only ``meta.request_cost_usd`` on priced records.
-
-    The UI sums these per turn to show a per-reply cost; pricing stays
-    server-side. A record whose usage cannot be priced keeps no field —
-    absent means unknown. Nothing is persisted.
-    """
-
-    enriched: list[ConversationMessage] = []
-    for message in messages:
-        meta = message.get("meta") or {}
-        usage = meta.get("usage")
-        if message.get("role") in {"assistant", "compact"} and isinstance(usage, dict):
-            metadata = resolve_model_metadata(
-                provider=str(meta.get("provider") or ""), model=str(meta.get("model") or "")
-            )
-            cost = estimate_cost(usage, metadata.cost)
-            if cost is not None:
-                message = {**message, "meta": {**meta, "request_cost_usd": cost}}
-        enriched.append(message)
-    return enriched
-
-
 @router.post("")
 async def create_session(req: SessionCreateRequest, store: StoreDep) -> dict[str, Any]:
     cwd = resolve_workspace_cwd(req.cwd)
@@ -89,19 +65,19 @@ async def load_session(
     if active:
         return {
             "session": data["session"] if data else None,
-            "messages": _redact_document_data(_with_request_costs(active["messages"])),
-            "session_cost_usd": session_cost,
+            "messages": _redact_document_data(active["messages"]),
+            "session_cost": session_cost,
             "active_run": active["run"],
             "pending_events": active["pending_events"],
         }
 
     if data is None:
-        return {"session": None, "messages": [], "session_cost_usd": None, "active_run": None, "pending_events": []}
+        return {"session": None, "messages": [], "session_cost": None, "active_run": None, "pending_events": []}
 
     return {
         "session": data["session"],
-        "messages": _redact_document_data(_with_request_costs(data["messages"])),
-        "session_cost_usd": session_cost,
+        "messages": _redact_document_data(data["messages"]),
+        "session_cost": session_cost,
         "active_run": None,
         "pending_events": [],
     }

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/server/routers/settings.py

@@ -26,6 +26,7 @@ from mycode.providers import (
 from mycode_cli.config import (
     PERMISSION_LEVEL_OPTIONS,
     PERMISSION_MODE_OPTIONS,
+    WEB_PROVIDER_ENV_VARS,
     is_api_key_env_ref,
     resolve_mycode_home,
     validate_global_config,
@@ -54,33 +55,39 @@ def _present_config(raw: dict[str, Any]) -> dict[str, Any]:
 
     out = copy.deepcopy(raw)
     providers = out.get("providers")
-    if not isinstance(providers, dict):
-        return out
+    if isinstance(providers, dict):
+        for entry in providers.values():
+            if not isinstance(entry, dict):
+                continue
+            _mask_api_key(entry)
+            models = entry.get("models")
+            if isinstance(models, dict):
+                entry["models"] = list(models.keys())
+                overrides = {k: v for k, v in models.items() if isinstance(v, dict) and v}
+                if overrides:
+                    entry["model_overrides"] = overrides
+
+    web = out.get("web")
+    if isinstance(web, dict):
+        for provider in ("tavily", "exa"):
+            entry = web.get(provider)
+            if isinstance(entry, dict):
+                _mask_api_key(entry)
+
+    return out
 
-    for entry in providers.values():
-        if not isinstance(entry, dict):
-            continue
 
-        api_key = entry.get("api_key")
-        if isinstance(api_key, str) and api_key.strip():
-            if is_api_key_env_ref(api_key):
-                # ${VAR} stays visible — it's not the secret itself.
-                entry["api_key_saved"] = False
-            else:
-                entry["api_key"] = None
-                entry["api_key_saved"] = True
+def _mask_api_key(entry: dict[str, Any]) -> None:
+    api_key = entry.get("api_key")
+    if isinstance(api_key, str) and api_key.strip():
+        if is_api_key_env_ref(api_key):
+            entry["api_key_saved"] = False
         else:
             entry["api_key"] = None
-            entry["api_key_saved"] = False
-
-        models = entry.get("models")
-        if isinstance(models, dict):
-            entry["models"] = list(models.keys())
-            overrides = {k: v for k, v in models.items() if isinstance(v, dict) and v}
-            if overrides:
-                entry["model_overrides"] = overrides
-
-    return out
+            entry["api_key_saved"] = True
+    else:
+        entry["api_key"] = None
+        entry["api_key_saved"] = False
 
 
 def _env_presence(raw: dict[str, Any]) -> dict[str, bool]:
@@ -90,6 +97,7 @@ def _env_presence(raw: dict[str, Any]) -> dict[str, bool]:
     names: set[str] = set()
     for provider_id in list_env_discoverable_providers():
         names.update(provider_env_api_key_names(provider_id))
+    names.update(WEB_PROVIDER_ENV_VARS.values())
 
     for entry in (raw.get("providers") or {}).values():
         if isinstance(entry, dict):
@@ -99,6 +107,12 @@ def _env_presence(raw: dict[str, Any]) -> dict[str, bool]:
                 if ref:
                     names.add(ref)
 
+    for entry in (raw.get("web") or {}).values():
+        if isinstance(entry, dict):
+            api_key = entry.get("api_key")
+            if isinstance(api_key, str) and (ref := is_api_key_env_ref(api_key)):
+                names.add(ref)
+
     return {name: bool((os.environ.get(name) or "").strip()) for name in sorted(names)}
 
 
@@ -163,6 +177,18 @@ def put_settings_endpoint(payload: SettingsRequest) -> dict[str, Any]:
         else:
             entry.pop("api_key", None)
 
+    existing_web = existing.get("web") or {}
+    incoming_web = incoming.get("web") or {}
+    for provider in ("tavily", "exa"):
+        entry = incoming_web.get(provider) if isinstance(incoming_web, dict) else None
+        if not isinstance(entry, dict) or entry.get("api_key") is not None:
+            continue
+        prior = existing_web.get(provider) if isinstance(existing_web, dict) else None
+        if isinstance(prior, dict) and "api_key" in prior:
+            entry["api_key"] = prior["api_key"]
+        else:
+            entry.pop("api_key", None)
+
     try:
         cleaned = validate_global_config(incoming)
     except ValueError as exc:

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/server/run_manager.py

@@ -20,6 +20,14 @@ RunStatus = Literal["running", "completed", "failed", "cancelled"]
 RunKind = Literal["chat", "compact"]
 FINISHED_RUN_TTL_SECONDS = 300
 RUN_EVENT_BUFFER_SIZE = 2000
+RUN_TOOL_OUTPUT_BUFFER_BYTES = 1_000_000
+
+
+def _tool_output_bytes(payload: dict[str, Any]) -> int:
+    if payload.get("type") != "tool_output":
+        return 0
+    output = payload.get("output")
+    return len(output.encode("utf-8")) if isinstance(output, str) else 0
 
 
 class ActiveRunError(RuntimeError):
@@ -57,6 +65,7 @@ class RunState:
     status: RunStatus = "running"
     error: str | None = None
     events: list[dict[str, Any]] = field(default_factory=list)
+    tool_output_bytes: int = 0
     next_seq: int = 1
     task: asyncio.Task[None] | None = None
     finished_at: float | None = None
@@ -323,9 +332,11 @@ class RunManager:
                     if event.type == "error":
                         last_error = str(event.data.get("message") or "unknown error")
                     elif event.type == "usage":
+                        turn_cost = event.data.get("turn_cost")
+                        turn_total = turn_cost.get("total") if isinstance(turn_cost, dict) else None
                         session_cost = sum_known_costs(
                             state.session_cost_base,
-                            event.data.get("turn_cost_usd"),
+                            turn_total,
                         )
                         event = Event(
                             "usage",
@@ -333,7 +344,7 @@ class RunManager:
                                 **event.data,
                                 "context_window": state.agent.context_window,
                                 "model": state.agent.model,
-                                "session_cost_usd": session_cost,
+                                "session_cost": session_cost,
                             },
                         )
                     await self._append_event(state, event)
@@ -360,11 +371,23 @@ class RunManager:
 
     async def _append_event(self, state: RunState, event: Event) -> None:
         async with state.condition:
+            if event.type == "tool_done":
+                tool_use_id = event.data.get("tool_use_id")
+                retained = [
+                    payload
+                    for payload in state.events
+                    if payload.get("type") != "tool_output" or payload.get("tool_use_id") != tool_use_id
+                ]
+                state.events = retained
+                state.tool_output_bytes = sum(_tool_output_bytes(payload) for payload in retained)
+
             payload = {"seq": state.next_seq, "type": event.type, **event.data}
             state.next_seq += 1
             state.events.append(payload)
-            if len(state.events) > RUN_EVENT_BUFFER_SIZE:
-                del state.events[: len(state.events) - RUN_EVENT_BUFFER_SIZE]
+            state.tool_output_bytes += _tool_output_bytes(payload)
+            while len(state.events) > RUN_EVENT_BUFFER_SIZE or state.tool_output_bytes > RUN_TOOL_OUTPUT_BUFFER_BYTES:
+                removed = state.events.pop(0)
+                state.tool_output_bytes -= _tool_output_bytes(removed)
             state.condition.notify_all()
 
     async def _finish_run(self, state: RunState, *, status: RunStatus, error: str | None = None) -> None:

{mycode_cli-0.12.0 → mycode_cli-0.13.0}/src/mycode_cli/server/schemas.py

@@ -6,6 +6,8 @@ from typing import Any, Literal, Self
 
 from pydantic import BaseModel, Field, model_validator
 
+from mycode.models import Cost
+
 RunKind = Literal["chat", "compact"]
 
 
@@ -104,8 +106,8 @@ class StreamEvent(BaseModel):
     context_window: int | None = None  # usage
     model: str | None = None  # usage
     turn_usage: dict[str, int] | None = None  # usage
-    turn_cost_usd: float | None = None  # usage
-    session_cost_usd: float | None = None  # usage; composed by the run manager
+    turn_cost: Cost | None = None  # usage
+    session_cost: float | None = None  # usage; composed by the run manager
 
 
 class DecideRequest(BaseModel):