runspec-console 0.1.0__py3-none-any.whl

runspec_console/__init__.py

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

runspec_console/adapters/anthropic.py

@@ -0,0 +1,117 @@
+"""pip install runspec-console[anthropic]"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import anthropic
+
+from .base import ChatResponse, ModelAdapter, ToolCall
+
+DEFAULT_MODEL = "claude-sonnet-4-6"
+DEFAULT_SYSTEM = (
+    "You are a helpful assistant with access to runspec tools running on local and remote hosts. "
+    "Use tools when they help answer the user's request. "
+    "When you call a tool, briefly explain what you're doing before the result."
+)
+
+
+class AnthropicAdapter(ModelAdapter):
+    def __init__(
+        self,
+        model: str = DEFAULT_MODEL,
+        system: str = DEFAULT_SYSTEM,
+        api_key: str | None = None,
+    ) -> None:
+        self.client = anthropic.AsyncAnthropic(api_key=api_key)
+        self.model = model
+        self.system = system
+
+    async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> ChatResponse:
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+        response = await self.client.messages.create(**kwargs)
+        text = next(
+            (block.text for block in response.content if hasattr(block, "text")), None
+        )
+        tool_calls = [
+            ToolCall(id=block.id, name=block.name, input=block.input)
+            for block in response.content
+            if block.type == "tool_use"
+        ]
+        return ChatResponse(text=text, tool_calls=tool_calls, stop_reason=response.stop_reason, _raw=response)
+
+    async def stream_chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]):  # type: ignore[override]
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+        async with self.client.messages.stream(**kwargs) as stream:
+            async for token in stream.text_stream:
+                yield token
+
+    async def stream_with_tools(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]):  # type: ignore[override]
+        import json
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+        # Collect tool input JSON chunks indexed by content-block position
+        tool_map: dict[int, dict[str, Any]] = {}
+        stop_reason = "end_turn"
+        async with self.client.messages.stream(**kwargs) as stream:
+            async for event in stream:
+                ev_type = getattr(event, "type", None)
+                if ev_type == "content_block_start":
+                    cb = getattr(event, "content_block", None)
+                    if cb and getattr(cb, "type", None) == "tool_use":
+                        tool_map[event.index] = {"id": cb.id, "name": cb.name, "json": ""}
+                elif ev_type == "content_block_delta":
+                    d = getattr(event, "delta", None)
+                    if d:
+                        if getattr(d, "type", None) == "text_delta":
+                            yield ("text", d.text)
+                        elif getattr(d, "type", None) == "input_json_delta":
+                            if event.index in tool_map:
+                                tool_map[event.index]["json"] += d.partial_json
+                elif ev_type == "message_delta":
+                    d = getattr(event, "delta", None)
+                    if d:
+                        stop_reason = getattr(d, "stop_reason", stop_reason) or stop_reason
+            final = await stream.get_final_message()
+        tool_calls = []
+        for tc in tool_map.values():
+            try:
+                inp = json.loads(tc["json"]) if tc["json"] else {}
+            except Exception:
+                inp = {}
+            tool_calls.append(ToolCall(id=tc["id"], name=tc["name"], input=inp))
+        yield ("done", ChatResponse(text=None, tool_calls=tool_calls, stop_reason=stop_reason, _raw=final))
+
+    def make_tool_turn(
+        self, response: ChatResponse, results: list[tuple[ToolCall, str]]
+    ) -> list[dict[str, Any]]:
+        return [
+            {"role": "assistant", "content": response._raw.content},
+            {
+                "role": "user",
+                "content": [
+                    {"type": "tool_result", "tool_use_id": tc.id, "content": result}
+                    for tc, result in results
+                ],
+            },
+        ]

runspec_console/adapters/base.py

@@ -0,0 +1,92 @@
+"""
+base.py — ModelAdapter ABC shared across all LLM providers.
+
+Identical contract to runspec-chat's adapter.py so implementations
+can be ported between the two packages without changes.
+"""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, AsyncIterator
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    input: dict[str, Any]
+
+
+@dataclass
+class ChatResponse:
+    text: str | None
+    tool_calls: list[ToolCall]
+    stop_reason: str   # "tool_use" | "end_turn" | "stop"
+    _raw: Any = field(repr=False, default=None)
+
+
+class ModelAdapter(ABC):
+    @abstractmethod
+    async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> ChatResponse: ...
+
+    @abstractmethod
+    def stream_chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> AsyncIterator[str]:
+        """Yield text tokens as they arrive from the model."""
+        ...
+
+    async def stream_with_tools(
+        self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]
+    ):
+        """
+        Yield ('text', str) for each text token, then ('done', ChatResponse) at the end.
+
+        Default falls back to non-streaming chat(). Override for true streaming with tools.
+        """
+        response = await self.chat(messages, tools)
+        if response.text:
+            yield ("text", response.text)
+        yield ("done", response)
+
+    @abstractmethod
+    def make_tool_turn(
+        self, response: ChatResponse, results: list[tuple[ToolCall, str]]
+    ) -> list[dict[str, Any]]:
+        """Return [assistant_turn, tool_result_turn] to append to the conversation."""
+        ...
+
+
+def load_adapter(provider: str, **kwargs: Any) -> ModelAdapter:
+    """
+    Instantiate the named adapter.  Raises ImportError with install instructions
+    if the required extra is not installed.
+
+    provider: "anthropic" | "openai" | "bedrock"
+    kwargs:   passed straight through to the adapter __init__
+    """
+    if provider == "anthropic":
+        try:
+            from .anthropic import AnthropicAdapter
+            return AnthropicAdapter(**kwargs)
+        except ImportError:
+            raise ImportError(
+                "Install the Anthropic extra: pip install runspec-console[anthropic]"
+            )
+    if provider == "openai":
+        try:
+            from .openai import OpenAIAdapter
+            return OpenAIAdapter(**kwargs)
+        except ImportError:
+            raise ImportError(
+                "Install the OpenAI extra: pip install runspec-console[openai]"
+            )
+    if provider == "bedrock":
+        try:
+            from .bedrock import BedrockAdapter
+            return BedrockAdapter(**kwargs)
+        except ImportError:
+            raise ImportError(
+                "Install the Bedrock extra: pip install runspec-console[bedrock]"
+            )
+    raise ValueError(f"Unknown LLM provider: {provider!r}. Choose from: anthropic, openai, bedrock")

runspec_console/adapters/bedrock.py

@@ -0,0 +1,145 @@
+"""
+pip install runspec-console[bedrock]
+
+Uses anthropic[bedrock] — Claude models via AWS Bedrock.
+
+Standard auth: AWS credential chain (env vars, ~/.aws/credentials, IAM role).
+Custom proxy auth: set base_url + api_key (HTTP Basic token) for a corporate
+Bedrock proxy — the anthropic SDK passes api_key as the Authorization header.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import anthropic
+
+from .base import ChatResponse, ModelAdapter, ToolCall
+
+DEFAULT_MODEL = "anthropic.claude-sonnet-4-6"
+DEFAULT_SYSTEM = (
+    "You are a helpful assistant with access to runspec tools running on local and remote hosts. "
+    "Use tools when they help answer the user's request. "
+    "When you call a tool, briefly explain what you're doing before the result."
+)
+
+
+class BedrockAdapter(ModelAdapter):
+    def __init__(
+        self,
+        model: str = DEFAULT_MODEL,
+        system: str = DEFAULT_SYSTEM,
+        aws_region: str | None = None,
+        aws_access_key: str | None = None,
+        aws_secret_key: str | None = None,
+        aws_session_token: str | None = None,
+        # Corporate proxy path: supply base_url + token instead of AWS creds
+        base_url: str | None = None,
+        api_key: str | None = None,
+    ) -> None:
+        self.model = model
+        self.system = system
+        if base_url:
+            # Corporate proxy — treat as a regular Anthropic-compatible endpoint
+            self.client: anthropic.AsyncAnthropic | anthropic.AsyncAnthropicBedrock = (
+                anthropic.AsyncAnthropic(base_url=base_url, api_key=api_key or "unused")
+            )
+        else:
+            kwargs: dict[str, Any] = {}
+            if aws_region:
+                kwargs["aws_region"] = aws_region
+            if aws_access_key:
+                kwargs["aws_access_key"] = aws_access_key
+            if aws_secret_key:
+                kwargs["aws_secret_key"] = aws_secret_key
+            if aws_session_token:
+                kwargs["aws_session_token"] = aws_session_token
+            self.client = anthropic.AsyncAnthropicBedrock(**kwargs)
+
+    async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> ChatResponse:
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+        response = await self.client.messages.create(**kwargs)
+        text = next(
+            (block.text for block in response.content if hasattr(block, "text")), None
+        )
+        tool_calls = [
+            ToolCall(id=block.id, name=block.name, input=block.input)
+            for block in response.content
+            if block.type == "tool_use"
+        ]
+        return ChatResponse(text=text, tool_calls=tool_calls, stop_reason=response.stop_reason, _raw=response)
+
+    async def stream_chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]):  # type: ignore[override]
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+        async with self.client.messages.stream(**kwargs) as stream:
+            async for token in stream.text_stream:
+                yield token
+
+    async def stream_with_tools(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]):  # type: ignore[override]
+        import json
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            max_tokens=4096,
+            messages=messages,
+            system=self.system,
+        )
+        if tools:
+            kwargs["tools"] = tools
+        tool_map: dict[int, dict[str, Any]] = {}
+        stop_reason = "end_turn"
+        async with self.client.messages.stream(**kwargs) as stream:
+            async for event in stream:
+                ev_type = getattr(event, "type", None)
+                if ev_type == "content_block_start":
+                    cb = getattr(event, "content_block", None)
+                    if cb and getattr(cb, "type", None) == "tool_use":
+                        tool_map[event.index] = {"id": cb.id, "name": cb.name, "json": ""}
+                elif ev_type == "content_block_delta":
+                    d = getattr(event, "delta", None)
+                    if d:
+                        if getattr(d, "type", None) == "text_delta":
+                            yield ("text", d.text)
+                        elif getattr(d, "type", None) == "input_json_delta":
+                            if event.index in tool_map:
+                                tool_map[event.index]["json"] += d.partial_json
+                elif ev_type == "message_delta":
+                    d = getattr(event, "delta", None)
+                    if d:
+                        stop_reason = getattr(d, "stop_reason", stop_reason) or stop_reason
+            final = await stream.get_final_message()
+        tool_calls = []
+        for tc in tool_map.values():
+            try:
+                inp = json.loads(tc["json"]) if tc["json"] else {}
+            except Exception:
+                inp = {}
+            tool_calls.append(ToolCall(id=tc["id"], name=tc["name"], input=inp))
+        yield ("done", ChatResponse(text=None, tool_calls=tool_calls, stop_reason=stop_reason, _raw=final))
+
+    def make_tool_turn(
+        self, response: ChatResponse, results: list[tuple[ToolCall, str]]
+    ) -> list[dict[str, Any]]:
+        return [
+            {"role": "assistant", "content": response._raw.content},
+            {
+                "role": "user",
+                "content": [
+                    {"type": "tool_result", "tool_use_id": tc.id, "content": result}
+                    for tc, result in results
+                ],
+            },
+        ]

runspec_console/adapters/openai.py

@@ -0,0 +1,97 @@
+"""pip install runspec-console[openai]"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import openai as _openai
+
+from .base import ChatResponse, ModelAdapter, ToolCall
+
+DEFAULT_MODEL = "gpt-4o"
+DEFAULT_SYSTEM = (
+    "You are a helpful assistant with access to runspec tools running on local and remote hosts. "
+    "Use tools when they help answer the user's request. "
+    "When you call a tool, briefly explain what you're doing before the result."
+)
+
+
+def _to_openai_function(t: dict[str, Any]) -> dict[str, Any]:
+    """Convert Anthropic-format tool (input_schema) to OpenAI function format (parameters)."""
+    func: dict[str, Any] = {"name": t["name"]}
+    if t.get("description"):
+        func["description"] = t["description"]
+    func["parameters"] = t.get("input_schema") or t.get("parameters") or {
+        "type": "object", "properties": {}
+    }
+    return func
+
+
+class OpenAIAdapter(ModelAdapter):
+    def __init__(
+        self,
+        model: str = DEFAULT_MODEL,
+        system: str = DEFAULT_SYSTEM,
+        api_key: str | None = None,
+        base_url: str | None = None,
+    ) -> None:
+        self.client = _openai.AsyncOpenAI(api_key=api_key, base_url=base_url)
+        self.model = model
+        self.system = system
+
+    async def chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]) -> ChatResponse:
+        system_msg = {"role": "system", "content": self.system}
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            messages=[system_msg, *messages],
+        )
+        if tools:
+            kwargs["tools"] = [{"type": "function", "function": _to_openai_function(t)} for t in tools]
+            kwargs["tool_choice"] = "auto"
+        response = await self.client.chat.completions.create(**kwargs)
+        msg = response.choices[0].message
+        text = msg.content
+        tool_calls = []
+        if msg.tool_calls:
+            import json
+            tool_calls = [
+                ToolCall(id=tc.id, name=tc.function.name, input=json.loads(tc.function.arguments))
+                for tc in msg.tool_calls
+            ]
+        stop = response.choices[0].finish_reason or "stop"
+        return ChatResponse(text=text, tool_calls=tool_calls, stop_reason=stop, _raw=response)
+
+    async def stream_chat(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]):  # type: ignore[override]
+        system_msg = {"role": "system", "content": self.system}
+        kwargs: dict[str, Any] = dict(
+            model=self.model,
+            messages=[system_msg, *messages],
+            stream=True,
+        )
+        if tools:
+            kwargs["tools"] = [{"type": "function", "function": _to_openai_function(t)} for t in tools]
+            kwargs["tool_choice"] = "auto"
+        async for chunk in await self.client.chat.completions.create(**kwargs):
+            delta = chunk.choices[0].delta.content
+            if delta:
+                yield delta
+
+    async def stream_with_tools(self, messages: list[dict[str, Any]], tools: list[dict[str, Any]]):  # type: ignore[override]
+        # Fall back to non-streaming chat() — accumulating streaming deltas for tool calls
+        # requires complex state management; non-streaming is simpler and correct for tool turns.
+        response = await self.chat(messages, tools)
+        if response.text:
+            yield ("text", response.text)
+        yield ("done", response)
+
+    def make_tool_turn(
+        self, response: ChatResponse, results: list[tuple[ToolCall, str]]
+    ) -> list[dict[str, Any]]:
+        raw_msg = response._raw.choices[0].message
+        turns: list[dict[str, Any]] = [{"role": "assistant", "content": raw_msg.content, "tool_calls": [
+            {"id": tc.id, "type": "function", "function": {"name": tc.name, "arguments": str(tc.input)}}
+            for tc, _ in results
+        ]}]
+        for tc, result in results:
+            turns.append({"role": "tool", "tool_call_id": tc.id, "content": result})
+        return turns

runspec_console/app.py

@@ -0,0 +1,95 @@
+"""
+app.py — pywebview entry point for runspec-console.
+
+Dev mode  (--dev):  points the window at the Vite dev server (http://localhost:<port>)
+Prod mode (default): serves the built Vite dist folder via a local HTTP server.
+
+Usage:
+  runspec-console            # production — requires packages/console-ui/dist/
+  runspec-console --dev      # development — requires `npm run dev` running
+  runspec-console --dev --port 5174
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+import threading
+from http.server import HTTPServer, SimpleHTTPRequestHandler
+from pathlib import Path
+
+
+def _find_dist() -> Path:
+    """Locate the built console-ui dist folder relative to this package."""
+    candidates = [
+        # Installed package data (future: bundle dist into the wheel)
+        Path(__file__).parent / "dist",
+        # Development: sibling packages directory
+        Path(__file__).parents[3] / "console-ui" / "dist",
+    ]
+    for c in candidates:
+        if (c / "index.html").exists():
+            return c
+    raise FileNotFoundError(
+        "console-ui dist not found. Run `npm run build` in packages/console-ui, "
+        "or use --dev to point at the Vite dev server instead."
+    )
+
+
+def _start_static_server(dist: Path) -> int:
+    """Serve dist/ on a random free port. Returns the port number."""
+    import socket
+
+    class _Handler(SimpleHTTPRequestHandler):
+        def __init__(self, *a: object, **kw: object) -> None:
+            super().__init__(*a, directory=str(dist), **kw)
+
+        def log_message(self, *_: object) -> None:
+            pass   # silence request logs
+
+    with socket.socket() as s:
+        s.bind(("127.0.0.1", 0))
+        port = s.getsockname()[1]
+
+    server = HTTPServer(("127.0.0.1", port), _Handler)
+    t = threading.Thread(target=server.serve_forever, daemon=True)
+    t.start()
+    return port
+
+
+def main() -> None:
+    import runspec
+
+    args = runspec.parse("runspec-console")
+    dev: bool = bool(args.dev.value)
+    port: int = int(args.port.value) if args.port.value is not None else 5173
+
+    import webview
+
+    from .bridge import Bridge
+
+    bridge = Bridge()
+
+    if dev:
+        url = f"http://localhost:{port}"
+    else:
+        try:
+            dist = _find_dist()
+            static_port = _start_static_server(dist)
+            url = f"http://127.0.0.1:{static_port}"
+        except FileNotFoundError as exc:
+            print(f"✗  {exc}", file=sys.stderr)
+            sys.exit(1)
+
+    window = webview.create_window(
+        "runspec console",
+        url,
+        js_api=bridge,
+        width=1440,
+        height=900,
+        min_size=(1024, 600),
+        frameless=True,
+    )
+    bridge.set_window(window)
+
+    webview.start(debug=dev)