tylor-mcp 1.0.0

package/server/tools/router.py

@@ -0,0 +1,117 @@
+"""
+server/tools/router.py — model routing with transparent overflow fallback.
+
+Routes normal message calls through the primary Claude client. If the primary
+route hits a rate limit, retries the identical request through Claude Platform
+on AWS. context_length_exceeded is not retried — the identical payload would
+fail on the platform route too.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+logger = logging.getLogger(__name__)
+
+from mcp.shared.exceptions import McpError
+from mcp.types import ErrorData, INTERNAL_ERROR
+
+OVERFLOW_ERROR_TYPES = {"rate_limit_error"}
+AWS_PLATFORM_BASE_URL_TEMPLATE = "https://aws-external-anthropic.{region}.api.aws"
+
+
+def _error_type(exc: BaseException) -> str:
+    """Extract Anthropic-style error type from SDK or API exceptions."""
+    direct_type = getattr(exc, "type", None)
+    if isinstance(direct_type, str):
+        return direct_type
+
+    error = getattr(exc, "error", None)
+    nested_type = getattr(error, "type", None)
+    if isinstance(nested_type, str):
+        return nested_type
+    if isinstance(error, Mapping):
+        mapped_type = error.get("type")
+        if isinstance(mapped_type, str):
+            return mapped_type
+
+    message = str(exc).lower()
+    for error_type in OVERFLOW_ERROR_TYPES:
+        if error_type in message:
+            return error_type
+    return ""
+
+
+def is_overflow_error(exc: BaseException) -> bool:
+    """Return True only for errors that should trigger Platform on AWS fallback."""
+    return _error_type(exc) in OVERFLOW_ERROR_TYPES
+
+
+def _internal_error(message: str) -> McpError:
+    return McpError(ErrorData(code=INTERNAL_ERROR, message=message))
+
+
+@dataclass
+class ModelRouter:
+    """Message router with primary route and Claude Platform on AWS fallback."""
+
+    primary_client: Any
+    platform_client: Any | None = None
+
+    def create_message(self, **request: Any) -> Any:
+        """
+        Create a Claude message through primary route, falling back only for
+        rate-limit errors. The fallback receives the identical request kwargs.
+        """
+        try:
+            return self.primary_client.messages.create(**request)
+        except Exception as primary_exc:
+            if not is_overflow_error(primary_exc):
+                raise
+            if self.platform_client is None:
+                from server.config import config
+                if not config.get("platform_key"):
+                    logger.warning(
+                        "platform_client is null — ANTHROPIC_PLATFORM_AWS_API_KEY not configured; "
+                        "overflow fallback unavailable"
+                    )
+                    raise _internal_error("All model routes exhausted") from primary_exc
+            try:
+                platform = self.platform_client or build_platform_client()
+                self.platform_client = platform
+                return platform.messages.create(**request)
+            except Exception as platform_exc:
+                raise _internal_error("All model routes exhausted") from platform_exc
+
+
+def build_platform_base_url(region: str) -> str:
+    """Build the regional Claude Platform on AWS endpoint."""
+    return AWS_PLATFORM_BASE_URL_TEMPLATE.format(region=region)
+
+
+def build_platform_client() -> Any:
+    """Construct an Anthropic SDK client for Claude Platform on AWS."""
+    from anthropic import Anthropic
+    from server.config import config
+
+    platform_key = config.get("platform_key")
+    if not platform_key:
+        raise RuntimeError("ANTHROPIC_PLATFORM_AWS_API_KEY not configured")
+
+    base_url = config.get("platform_base_url") or build_platform_base_url(
+        config.get("bedrock_region", "us-east-1")
+    )
+    workspace_id = config.get("platform_workspace_id")
+    headers = {"anthropic-workspace-id": workspace_id} if workspace_id else None
+
+    return Anthropic(
+        api_key=platform_key,
+        base_url=base_url,
+        default_headers=headers,
+    )
+
+
+def create_message(primary_client: Any, **request: Any) -> Any:
+    """Convenience wrapper for call sites that do not need a router instance."""
+    return ModelRouter(primary_client=primary_client).create_message(**request)

package/server/tools/skill_installer.py

@@ -0,0 +1,230 @@
+"""Skill package installer for the /add-skill command."""
+from __future__ import annotations
+import json
+import re
+import shutil
+import argparse
+from datetime import datetime, timezone
+from pathlib import Path
+
+from mcp.shared.exceptions import McpError
+from mcp.server.fastmcp.exceptions import ToolError
+from mcp.types import ErrorData, INVALID_PARAMS
+
+from ._mcp import mcp
+
+PLUGIN_DIR = Path(__file__).resolve().parents[2]
+DEFAULT_SKILLS_DIR = PLUGIN_DIR / "skills"
+DEFAULT_REGISTRY_PATH = PLUGIN_DIR / "registry.json"
+
+_STOPWORDS = {
+    "and",
+    "for",
+    "the",
+    "this",
+    "that",
+    "use",
+    "user",
+    "when",
+    "wants",
+    "with",
+}
+
+
+def _invalid_params(message: str) -> McpError:
+    return McpError(ErrorData(code=INVALID_PARAMS, message=message))
+
+
+def _now_date() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%d")
+
+
+def _read_registry(path: Path) -> dict:
+    if not path.exists():
+        return {"version": "1.0", "skills": []}
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _write_registry(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    tmp.replace(path)
+
+
+def _parse_frontmatter_value(value: str):
+    value = value.strip()
+    if value.startswith("[") and value.endswith("]"):
+        try:
+            return json.loads(value)
+        except json.JSONDecodeError:
+            pass
+    return value.strip("'\"")
+
+
+def _frontmatter(text: str) -> dict:
+    if not text.startswith("---\n"):
+        return {}
+    end = text.find("\n---", 4)
+    if end == -1:
+        return {}
+    data = {}
+    for line in text[4:end].splitlines():
+        if ":" not in line:
+            continue
+        key, value = line.split(":", 1)
+        data[key.strip()] = _parse_frontmatter_value(value)
+    return data
+
+
+def _skill_name(source_path: Path, metadata: dict, explicit_name: str | None) -> str:
+    raw = explicit_name or metadata.get("name") or source_path.name
+    name = raw.strip().lower().replace(" ", "-").replace("_", "-")
+    if not re.match(r"^[a-z0-9][a-z0-9-]*$", name):
+        raise _invalid_params(f"Invalid skill name: {raw}")
+    return name
+
+
+def _trigger_description(text: str, metadata: dict) -> str:
+    description = metadata.get("description", "").strip()
+    if description:
+        return description
+    for line in text.splitlines():
+        line = line.strip()
+        if line.lower().startswith("use when"):
+            return line
+    return "No trigger description provided."
+
+
+def _keywords(name: str, trigger: str) -> list[str]:
+    words = re.findall(r"[a-z0-9]+", f"{name} {trigger}".lower())
+    seen = set()
+    keywords = []
+    for word in words:
+        if len(word) < 3 or word in _STOPWORDS or word in seen:
+            continue
+        seen.add(word)
+        keywords.append(word)
+    return keywords
+
+
+def _tool_count(text: str) -> int:
+    tool_refs = set(re.findall(r"`([a-zA-Z_][a-zA-Z0-9_]+)\(", text))
+    return len(tool_refs)
+
+
+def _copy_skill(source_path: Path, target_path: Path, overwrite: bool) -> None:
+    if target_path.exists():
+        if not overwrite:
+            raise _invalid_params(
+                f"Skill '{target_path.name}' already exists; rerun with overwrite=True to replace it."
+            )
+        shutil.rmtree(target_path)
+    shutil.copytree(source_path, target_path)
+
+
+def install_skill(
+    source_path: str | Path,
+    name: str | None = None,
+    overwrite: bool = False,
+    skills_dir: str | Path = DEFAULT_SKILLS_DIR,
+    registry_path: str | Path = DEFAULT_REGISTRY_PATH,
+) -> dict:
+    """Copy a skill package and upsert its generated registry entry."""
+    source = Path(source_path).expanduser().resolve()
+    skill_file = source / "SKILL.md"
+    if not skill_file.exists():
+        raise _invalid_params(f"SKILL.md not found in {source}")
+
+    text = skill_file.read_text(encoding="utf-8")
+    metadata = _frontmatter(text)
+    skill_name = _skill_name(source, metadata, name)
+    trigger = _trigger_description(text, metadata)
+    target = Path(skills_dir) / skill_name
+    registry = _read_registry(Path(registry_path))
+    skills = list(registry.get("skills", []))
+    exists = any(entry.get("name") == skill_name for entry in skills)
+
+    if exists and not overwrite:
+        raise _invalid_params(
+            f"Skill '{skill_name}' already exists in registry.json; rerun with overwrite=True to replace it."
+        )
+
+    _copy_skill(source, target, overwrite=overwrite)
+
+    module = metadata.get("module")
+    tools = metadata.get("tools")
+    if isinstance(tools, str):
+        tools = [tools]
+    if tools is not None and not isinstance(tools, list):
+        raise _invalid_params("Invalid tools metadata in SKILL.md; use a comma-separated list or JSON array.")
+
+    entry = {
+        "name": skill_name,
+        "trigger": trigger,
+        "trigger_description": trigger,
+        "keywords": _keywords(skill_name, trigger),
+        "tool_count": _tool_count(text),
+        "installed_date": _now_date(),
+        "source_path": str(source),
+    }
+    if module:
+        entry["module"] = str(module)
+    if tools:
+        entry["tools"] = [str(tool).strip() for tool in tools if str(tool).strip()]
+
+    registry["skills"] = [entry for entry in skills if entry.get("name") != skill_name]
+    registry["skills"].append(entry)
+    _write_registry(Path(registry_path), registry)
+
+    return {
+        "status": "installed",
+        "name": skill_name,
+        "installed_to": str(target),
+        "registry_path": str(registry_path),
+    }
+
+
+@mcp.tool()
+def add_skill(
+    source_path: str,
+    name: str | None = None,
+    overwrite: bool = False,
+) -> dict:
+    """
+    Install an agent101 skill package and update registry.json.
+
+    Args:
+        source_path: Local path to a skill package directory containing SKILL.md.
+        name: Optional skill name override.
+        overwrite: Replace an existing installed skill if present.
+    """
+    try:
+        return install_skill(
+            source_path=source_path,
+            name=name,
+            overwrite=overwrite,
+        )
+    except McpError:
+        raise
+    except Exception as exc:
+        raise ToolError(f"add_skill failed: {exc}") from exc
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Install an agent101 skill package.")
+    parser.add_argument("source_path")
+    parser.add_argument("--name")
+    parser.add_argument("--overwrite", action="store_true")
+    args = parser.parse_args()
+
+    result = install_skill(
+        source_path=args.source_path,
+        name=args.name,
+        overwrite=args.overwrite,
+    )
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

package/server/tools/summarizer.py

@@ -0,0 +1,168 @@
+"""
+server/tools/summarizer.py — async thread summarization via Bedrock Opus.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from typing import Any
+
+import boto3
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_LAST_N_MESSAGES = 20
+DEFAULT_SUMMARY_MAX_TOKENS = 1024
+DEFAULT_BEDROCK_OPUS_MODEL = "us.anthropic.claude-opus-4-7-20251101-v1:0"
+
+
+def _message_text(message: dict) -> str:
+    role = message.get("Role") or message.get("role") or "unknown"
+    content = message.get("Content") or message.get("content") or ""
+    return f"{role}: {content}"
+
+
+def _last_messages(db: Any, thread_id: str, limit: int = DEFAULT_LAST_N_MESSAGES) -> list[dict]:
+    messages = db.query_thread(thread_id, f"THREAD#{thread_id}#MSG#")
+    messages.sort(key=lambda item: item.get("SK", ""))
+    return messages[-limit:]
+
+
+def _raw_fallback_summary(messages: list[dict]) -> str:
+    if not messages:
+        return "No messages were available for fallback summary."
+    return "\n".join(_message_text(message) for message in messages)
+
+
+def _extract_bedrock_text(response: dict) -> str:
+    body = response.get("body")
+    payload = body.read() if hasattr(body, "read") else body
+    if isinstance(payload, bytes):
+        payload = payload.decode("utf-8")
+    data = json.loads(payload)
+
+    content = data.get("content", [])
+    if isinstance(content, list):
+        parts = [
+            part.get("text", "")
+            for part in content
+            if isinstance(part, dict) and part.get("type") == "text"
+        ]
+        return "".join(parts).strip()
+    if isinstance(content, str):
+        return content.strip()
+    return ""
+
+
+def _summary_prompt(messages: list[dict]) -> str:
+    transcript = _raw_fallback_summary(messages)
+    return (
+        "Summarize this development thread for future context restoration. "
+        "Keep durable decisions, changed files, unresolved risks, and next steps.\n\n"
+        f"{transcript}"
+    )
+
+
+def _build_bedrock_client() -> Any:
+    from server.config import config
+
+    session_kwargs: dict[str, str] = {}
+    if config.get("aws_profile"):
+        session_kwargs["profile_name"] = config["aws_profile"]
+    session = boto3.Session(**session_kwargs)
+    return session.client(
+        "bedrock-runtime",
+        region_name=config.get("bedrock_region", "us-east-1"),
+    )
+
+
+def _bedrock_model_id() -> str:
+    from server.config import config
+
+    return config.get("bedrock_opus_model") or DEFAULT_BEDROCK_OPUS_MODEL
+
+
+def _mark_thread_killed(db: Any, thread_id: str) -> None:
+    meta = db.get_thread_meta(thread_id) or {}
+    attributes = dict(meta)
+    attributes["Status"] = "killed"
+    db.put_item(f"THREAD#{thread_id}#META", attributes)
+
+
+def _write_summary(
+    db: Any,
+    thread_id: str,
+    summary: str,
+    summary_type: str,
+    error: str | None = None,
+) -> None:
+    attributes = {
+        "Summary": summary,
+        "SummaryType": summary_type,
+    }
+    if error:
+        attributes["Error"] = error
+    db.put_item(f"THREAD#{thread_id}#SUMMARY", attributes)
+
+
+def _log_failure(db: Any, thread_id: str, error: str) -> None:
+    from server.tools.tylor import _now_iso
+
+    sk = f"THREAD#{thread_id}#MSG#{_now_iso()}#SUMMARY_FAILURE"
+    db.put_item(sk, {
+        "Role": "system",
+        "Content": f"kill_thread summarization failed: {error}",
+    })
+
+
+async def summarize_thread(
+    thread_id: str,
+    db: Any,
+    bedrock_client: Any | None = None,
+    model_id: str | None = None,
+    last_n: int = DEFAULT_LAST_N_MESSAGES,
+) -> None:
+    """
+    Summarize a thread, persist the result, and mark the thread killed.
+    On Bedrock failure, stores raw last-N messages and logs the failure.
+    """
+    messages = _last_messages(db, thread_id, last_n)
+    bedrock = bedrock_client or _build_bedrock_client()
+    model = model_id or _bedrock_model_id()
+
+    try:
+        body = {
+            "anthropic_version": "bedrock-2023-05-31",
+            "max_tokens": DEFAULT_SUMMARY_MAX_TOKENS,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": _summary_prompt(messages),
+                }
+            ],
+        }
+        response = await asyncio.to_thread(
+            bedrock.invoke_model,
+            modelId=model,
+            body=json.dumps(body),
+            contentType="application/json",
+            accept="application/json",
+        )
+        summary = _extract_bedrock_text(response)
+        if not summary:
+            raise RuntimeError("Bedrock returned an empty summary")
+        _write_summary(db, thread_id, summary, "bedrock_opus")
+    except Exception as exc:
+        error = str(exc)
+        logger.exception("Thread summarization failed for %s", thread_id)
+        _write_summary(
+            db,
+            thread_id,
+            _raw_fallback_summary(messages),
+            "raw_fallback",
+            error=error,
+        )
+        _log_failure(db, thread_id, error)
+    finally:
+        _mark_thread_killed(db, thread_id)