tsugite-claude-code 0.17.0__py3-none-any.whl

tsugite_claude_code/__init__.py

@@ -0,0 +1,5 @@
+"""Tsugite plugin: Claude Code provider (routes LLM calls through the claude CLI)."""
+
+from tsugite_claude_code.provider import ClaudeCodeProvider, create_provider
+
+__all__ = ["ClaudeCodeProvider", "create_provider"]

tsugite_claude_code/process.py

@@ -0,0 +1,315 @@
+"""Claude Code CLI subprocess provider.
+
+Routes LLM calls through `claude --print` instead of a direct HTTP provider,
+enabling Claude Max subscription auth. Text-only, no multimodal support.
+"""
+
+import asyncio
+import json
+import logging
+import os
+import shutil
+import tempfile
+import uuid
+from collections.abc import AsyncIterator
+
+from tsugite.cli.helpers import get_workspace_dir
+
+logger = logging.getLogger(__name__)
+
+# Env vars that must be unset to avoid "nested session" detection
+_CLAUDE_ENV_VARS = {"CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT", "ANTHROPIC_API_KEY"}
+
+# How long to wait for a graceful SIGTERM exit before escalating to SIGKILL.
+_STOP_TIMEOUT_SECONDS = 5.0
+
+# StreamReader buffer cap. asyncio defaults to 64KB, but a single stream-json
+# line (a long answer plus the result event's usage/modelUsage payload) routinely
+# exceeds that - and `readline()` then raises LimitOverrunError, crashing the turn
+# on stdout or killing the stderr drain into a pipe deadlock. 16MB is ample.
+_STREAM_READ_LIMIT = 16 * 1024 * 1024
+
+
+class ClaudeCodeProcess:
+    """Manages a persistent claude CLI subprocess for LLM completions.
+
+    Uses stream-json I/O format to send user turns via stdin and parse
+    streaming responses from stdout. The subprocess holds conversation
+    state in memory between turns.
+    """
+
+    def __init__(self):
+        self._process: asyncio.subprocess.Process | None = None  # pylint: disable=no-member
+        self._session_id: str | None = None
+        self._system_prompt_file: str | None = None
+        self._stderr_lines: list[str] = []
+        self._stderr_task: asyncio.Task | None = None
+        self._compacted: bool = False
+        self._last_usage: dict = {}
+
+    @property
+    def session_id(self) -> str | None:
+        return self._session_id
+
+    @property
+    def compacted(self) -> bool:
+        """Whether Claude Code auto-compacted during this session."""
+        return self._compacted
+
+    async def _drain_stderr(self) -> None:
+        """Background task: read stderr lines so the pipe never fills up.
+
+        Must keep draining even if one read fails - bailing on the first error
+        (e.g. an over-limit line) lets the OS stderr buffer fill, which blocks
+        the subprocess writing stderr and deadlocks the whole exchange.
+        """
+        while True:
+            try:
+                line = await self._process.stderr.readline()
+            except asyncio.CancelledError:
+                return
+            except Exception:
+                # A read error (e.g. transient decode/limit issue) must not stop
+                # the drain. Keep the pipe moving until EOF.
+                continue
+            if not line:
+                return
+            self._stderr_lines.append(line.decode(errors="replace").rstrip())
+
+    def _get_stderr(self) -> str:
+        return "\n".join(self._stderr_lines[-20:])  # last 20 lines
+
+    async def start(
+        self,
+        model: str,
+        system_prompt: str,
+        resume_session: str | None = None,
+        effort: str | None = None,
+    ) -> None:
+        """Launch persistent claude subprocess.
+
+        Args:
+            model: Model name (sonnet, opus, haiku, or full model ID)
+            system_prompt: System prompt text
+            resume_session: Optional session ID to resume instead of starting fresh
+            effort: Optional reasoning effort level passed via ``--effort``
+                (low, medium, high, xhigh, max).
+
+        Raises:
+            RuntimeError: If claude CLI is not found or fails to start
+        """
+        if not shutil.which("claude"):
+            raise RuntimeError("Claude Code CLI not found. Install it with: npm install -g @anthropic-ai/claude-code")
+
+        # Write system prompt to temp file
+        fd, self._system_prompt_file = tempfile.mkstemp(suffix=".txt", prefix="tsugite_sysprompt_")
+        with os.fdopen(fd, "w") as f:
+            f.write(system_prompt)
+
+        cmd = [
+            "claude",
+            "--print",
+            "--input-format",
+            "stream-json",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--max-turns",
+            "1",
+            "--model",
+            model,
+            "--tools",
+            "",
+            "--strict-mcp-config",
+            "--system-prompt-file",
+            self._system_prompt_file,
+        ]
+
+        if resume_session:
+            cmd.extend(["--resume", resume_session])
+        else:
+            cmd.extend(["--session-id", str(uuid.uuid4())])
+
+        if effort:
+            cmd.extend(["--effort", effort])
+
+        # Copy env but unset keys that trigger nested-session guard or API key usage
+        env = {k: v for k, v in os.environ.items() if k not in _CLAUDE_ENV_VARS}
+
+        workspace = get_workspace_dir()
+        self._process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            env=env,
+            cwd=str(workspace) if workspace is not None else None,
+            limit=_STREAM_READ_LIMIT,
+        )
+
+        # Start draining stderr in background to prevent pipe buffer deadlock
+        self._stderr_task = asyncio.create_task(self._drain_stderr())
+        mode = f"resume={resume_session}" if resume_session else "new session"
+        logger.info(
+            "Claude Code subprocess started (pid=%d, model=%s, effort=%s, %s)",
+            self._process.pid,
+            model,
+            effort or "default",
+            mode,
+        )
+
+    async def send_message(self, content: str) -> AsyncIterator[dict]:
+        """Write user message to stdin and yield streaming events from stdout.
+
+        Args:
+            content: User message text
+
+        Yields:
+            Dicts with type "text_delta" (streaming chunk) or "result" (final)
+
+        Raises:
+            RuntimeError: If subprocess has crashed
+        """
+        msg = {
+            "type": "user",
+            "message": {"role": "user", "content": content},
+            "session_id": self._session_id or "default",
+        }
+        content_len = len(content)
+        self._process.stdin.write((json.dumps(msg) + "\n").encode())
+        await self._process.stdin.drain()
+        logger.debug("Sent message (%d chars, ~%d est tokens): %.200s", content_len, content_len // 4, content)
+
+        # Text already emitted as content_block_delta chunks. The CLI repeats the
+        # full message text in the trailing `assistant` event, so without tracking
+        # what we already streamed the consumer would accumulate it twice (the
+        # duplicate-JSON / doubled-prose bug that marked passing Jobs stuck).
+        streamed_text = ""
+
+        while True:
+            line = await self._process.stdout.readline()
+            if not line:
+                stderr = self._get_stderr()
+                raise RuntimeError(
+                    f"Claude Code process ended unexpectedly (sent ~{content_len} chars). stderr: {stderr}"
+                )
+
+            raw = line.decode().strip()
+            if not raw:
+                continue
+
+            try:
+                event = json.loads(raw)
+            except json.JSONDecodeError:
+                continue
+
+            event_type = event.get("type", "")
+
+            # Init event — capture session_id (arrives after first user message)
+            if event_type == "system" and event.get("subtype") == "init":
+                self._session_id = event.get("session_id")
+                logger.debug("Init event received (session=%s)", self._session_id)
+                continue
+
+            # Compact boundary — Claude Code auto-compacted the conversation
+            if event_type == "system" and event.get("subtype") == "compact_boundary":
+                self._compacted = True
+                logger.info(
+                    "Claude Code auto-compacted (preTokens=%s)",
+                    event.get("compactMetadata", {}).get("preTokens"),
+                )
+                continue
+
+            # Content block delta (streaming with --include-partial-messages)
+            if event_type == "content_block_delta":
+                delta = event.get("delta", {})
+                if delta.get("type") == "text_delta":
+                    streamed_text += delta["text"]
+                    yield {"type": "text_delta", "text": delta["text"]}
+
+            # Full assistant message — extract text and usage from content blocks
+            elif event_type == "assistant":
+                message = event.get("message", {})
+                usage = message.get("usage", {})
+                if usage:
+                    self._last_usage = usage
+                content_blocks = message.get("content", [])
+                # Claude CLI redacts thinking text, leaving an empty payload, so drop it
+                # entirely rather than surfacing a content-free placeholder block.
+                text = "".join(block.get("text", "") for block in content_blocks if block.get("type") == "text")
+                # This event repeats the full message text. Emit only the part not
+                # already streamed as content_block_delta chunks; otherwise the
+                # consumer accumulates it twice. removeprefix is a no-op when no
+                # deltas streamed (prefix "") or the text isn't a clean prefix.
+                remainder = text.removeprefix(streamed_text)
+                if remainder:
+                    yield {"type": "text_delta", "text": remainder}
+                streamed_text = ""
+
+            # Final result
+            elif event_type == "result":
+                result_text = event.get("result", "")
+                cost = event.get("total_cost_usd")
+                duration = event.get("duration_ms")
+                logger.debug("Result received (cost=$%s, %sms): %.200s", cost, duration, result_text)
+
+                # Prefer usage from result event, fall back to last assistant event
+                result_usage = event.get("usage")
+                if not result_usage:
+                    logger.debug(
+                        "Result event missing usage; falling back to assistant event usage (cache tokens may be lost)"
+                    )
+                    result_usage = self._last_usage
+
+                # modelUsage is keyed by model name, e.g. {"claude-sonnet-4-6": {"contextWindow": 200000}}
+                context_window = None
+                for model_data in (event.get("modelUsage") or {}).values():
+                    context_window = model_data.get("contextWindow")
+                    if context_window:
+                        break
+
+                yield {
+                    "type": "result",
+                    "text": result_text,
+                    "cost_usd": cost,
+                    "duration_ms": duration,
+                    "session_id": event.get("session_id", self._session_id),
+                    "input_tokens": result_usage.get("input_tokens") or 0,
+                    "cache_creation_input_tokens": result_usage.get("cache_creation_input_tokens") or 0,
+                    "cache_read_input_tokens": result_usage.get("cache_read_input_tokens") or 0,
+                    "output_tokens": result_usage.get("output_tokens") or 0,
+                    "context_window": context_window,
+                    "is_error": bool(event.get("is_error")),
+                    "subtype": event.get("subtype"),
+                }
+                return
+
+            # Skip: rate_limit_event, system, etc.
+
+    async def stop(self) -> None:
+        """Terminate subprocess and clean up temp files."""
+        if self._stderr_task:
+            self._stderr_task.cancel()
+            self._stderr_task = None
+
+        if self._process:
+            try:
+                self._process.terminate()
+                try:
+                    # Bounded wait: a wedged or SIGTERM-ignoring claude (it's a
+                    # Node process) would otherwise hang this finally forever and
+                    # leak a long-lived orphan. Escalate to SIGKILL on timeout.
+                    await asyncio.wait_for(self._process.wait(), timeout=_STOP_TIMEOUT_SECONDS)
+                except asyncio.TimeoutError:
+                    logger.warning(
+                        "Claude Code subprocess (pid=%s) ignored SIGTERM; sending SIGKILL", self._process.pid
+                    )
+                    self._process.kill()
+                    await self._process.wait()
+            except ProcessLookupError:
+                pass
+            self._process = None
+
+        if self._system_prompt_file and os.path.exists(self._system_prompt_file):
+            os.unlink(self._system_prompt_file)
+            self._system_prompt_file = None

tsugite_claude_code/provider.py

@@ -0,0 +1,303 @@
+"""Claude Code provider — routes LLM calls through `claude --print` subprocess."""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, AsyncIterator
+
+from tsugite.exceptions import AgentExecutionError
+from tsugite.providers.base import CompletionResponse, ModelInfo, StreamChunk, Usage, default_count_tokens
+from tsugite.providers.model_registry import get_model_info as _get_model_info
+from tsugite.providers.model_registry import register_aliases, register_models
+
+logger = logging.getLogger(__name__)
+
+_CLAUDE_CODE_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"]
+
+_CLAUDE_CODE_MODELS: dict[str, ModelInfo] = {
+    "claude_code/claude-opus-4-8": ModelInfo(
+        max_input_tokens=1_000_000, supports_vision=True, supported_effort_levels=_CLAUDE_CODE_EFFORT_LEVELS
+    ),
+    "claude_code/claude-opus-4-7": ModelInfo(
+        max_input_tokens=1_000_000, supports_vision=True, supported_effort_levels=_CLAUDE_CODE_EFFORT_LEVELS
+    ),
+    "claude_code/claude-opus-4-6": ModelInfo(
+        max_input_tokens=1_000_000, supports_vision=True, supported_effort_levels=_CLAUDE_CODE_EFFORT_LEVELS
+    ),
+    "claude_code/claude-sonnet-4-6": ModelInfo(
+        max_input_tokens=1_000_000, supports_vision=True, supported_effort_levels=_CLAUDE_CODE_EFFORT_LEVELS
+    ),
+    "claude_code/claude-haiku-4-5-20251001": ModelInfo(
+        max_input_tokens=200_000, supports_vision=True, supported_effort_levels=_CLAUDE_CODE_EFFORT_LEVELS
+    ),
+}
+
+_ALIASES = {
+    "opus": "claude-opus-4-8",
+    "opus-4-8": "claude-opus-4-8",
+    "opus-4-7": "claude-opus-4-7",
+    "opus-4-6": "claude-opus-4-6",
+    "sonnet": "claude-sonnet-4-6",
+    "haiku": "claude-haiku-4-5-20251001",
+}
+
+
+def _raise_if_error(result_event: dict) -> None:
+    """Translate a Claude CLI error result into AgentExecutionError.
+
+    The CLI reports failures (context overflow, max-turns, etc.) as a result
+    event with is_error=true and a non-success subtype, NOT as a non-zero exit
+    or stderr. Without this conversion the failure text reaches the user as
+    the assistant's reply and bypasses the daemon's prompt-too-long retry path.
+    """
+    if not result_event.get("is_error"):
+        return
+    text = result_event.get("text") or "Claude Code returned an error result"
+    subtype = result_event.get("subtype") or "error"
+    raise AgentExecutionError(f"{text} (subtype={subtype})")
+
+
+class ClaudeCodeProvider:
+    """Provider that manages a persistent `claude` CLI subprocess.
+
+    Stateful: the subprocess persists across acompletion() calls within a session.
+    First call starts the process; subsequent calls send observations to it.
+    Call stop() to clean up the subprocess when done.
+    """
+
+    cacheable = False
+
+    def __init__(self, name: str = "claude_code"):
+        self.name = name
+        self._process = None
+        self._turn_count = 0
+        self._resolved_model: str | None = None
+
+        # Context set via set_context()
+        self._attachments = []
+        self._skills = []
+        self._resume_session = None
+        self._resume_after_compaction = False
+        self._previous_messages = []
+
+        # Session state
+        self._session_id: str | None = None
+        self._compacted: bool = False
+        self._context_window: int | None = None
+        self._cache_creation_tokens: int = 0
+        self._cache_read_tokens: int = 0
+        self._cumulative_cost: float = 0.0
+
+        register_models(_CLAUDE_CODE_MODELS)
+        register_aliases(self.name, _ALIASES)
+
+    def set_context(self, **kwargs: Any) -> None:
+        self._attachments = kwargs.get("attachments", [])
+        self._skills = kwargs.get("skills", [])
+        self._resume_session = kwargs.get("resume_session")
+        self._resume_after_compaction = kwargs.get("resume_after_compaction", False)
+        self._previous_messages = kwargs.get("previous_messages", [])
+
+    def get_state(self) -> dict | None:
+        return {
+            "session_id": self._session_id,
+            "compacted": self._compacted,
+            "context_window": self._context_window,
+            "cache_creation_tokens": self._cache_creation_tokens,
+            "cache_read_tokens": self._cache_read_tokens,
+        }
+
+    async def acompletion(
+        self,
+        messages: list[dict],
+        model: str,
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> CompletionResponse | AsyncIterator[StreamChunk]:
+        from tsugite_claude_code.process import ClaudeCodeProcess
+
+        resolved_model = _ALIASES.get(model, model)
+        if resolved_model != model and self._resolved_model != resolved_model:
+            logger.info("claude_code model alias %r -> %s", model, resolved_model)
+        self._resolved_model = resolved_model
+
+        if self._process is None:
+            self._process = ClaudeCodeProcess()
+            system_prompt = ""
+            if messages and messages[0].get("role") == "system":
+                system_prompt = messages[0]["content"]
+                messages = messages[1:]
+
+            await self._process.start(
+                model=resolved_model,
+                system_prompt=system_prompt,
+                resume_session=self._resume_session,
+                effort=kwargs.get("reasoning_effort"),
+            )
+            user_content = self._build_first_message(messages)
+        else:
+            # Subsequent turns: subprocess has context, send the last observation
+            user_content = messages[-1]["content"] if messages else ""
+
+        self._turn_count += 1
+
+        if stream:
+            return self._stream(user_content)
+
+        return await self._collect(user_content)
+
+    async def _collect(self, user_content: str) -> CompletionResponse:
+        """Send message and collect full response."""
+        accumulated = ""
+        usage = Usage()
+        cost = 0.0
+
+        async for event in self._process.send_message(user_content):
+            if event["type"] == "text_delta":
+                accumulated += event["text"]
+            elif event["type"] == "result":
+                _raise_if_error(event)
+                if not accumulated:
+                    accumulated = event.get("text", "")
+                cost = self._cost_delta(event.get("cost_usd") or 0.0)
+                usage = self._extract_usage(event)
+
+        return CompletionResponse(
+            content=accumulated,
+            usage=usage,
+            cost=cost,
+        )
+
+    async def _stream(self, user_content: str) -> AsyncIterator[StreamChunk]:
+        """Send message and yield streaming chunks."""
+        usage = Usage()
+        cost = 0.0
+
+        async for event in self._process.send_message(user_content):
+            if event["type"] == "text_delta":
+                yield StreamChunk(content=event["text"])
+            elif event["type"] == "result":
+                _raise_if_error(event)
+                cost = self._cost_delta(event.get("cost_usd") or 0.0)
+                usage = self._extract_usage(event)
+
+        yield StreamChunk(content="", done=True, usage=usage, cost=cost)
+
+    def _cost_delta(self, cumulative_cost: float) -> float:
+        """Convert Claude CLI's cumulative cost to a per-turn delta."""
+        delta = cumulative_cost - self._cumulative_cost
+        self._cumulative_cost = cumulative_cost
+        return max(delta, 0.0)
+
+    def _extract_usage(self, event: dict) -> Usage:
+        """Extract usage from a subprocess result event and update session state."""
+        input_tokens = event.get("input_tokens") or 0
+        cache_creation = event.get("cache_creation_input_tokens") or 0
+        cache_read = event.get("cache_read_input_tokens") or 0
+        output_tokens = event.get("output_tokens") or 0
+
+        self._cache_creation_tokens += cache_creation
+        self._cache_read_tokens += cache_read
+        self._session_id = event.get("session_id", self._session_id)
+        if event.get("context_window"):
+            self._context_window = event["context_window"]
+
+        return Usage(
+            prompt_tokens=input_tokens,
+            completion_tokens=output_tokens,
+            total_tokens=input_tokens + cache_creation + cache_read + output_tokens,
+            cache_creation_input_tokens=cache_creation,
+            cache_read_input_tokens=cache_read,
+        )
+
+    def _build_first_message(self, messages: list[dict]) -> str:
+        """Build the first user message, inlining attachments, skills, and history."""
+        parts = []
+
+        include_context = not self._resume_session or self._resume_after_compaction
+        if include_context and (self._attachments or self._skills):
+            from tsugite.attachments.base import AttachmentContentType, format_attachment_open_tag
+
+            context_parts = []
+            for att in self._attachments:
+                if att.content_type == AttachmentContentType.TEXT:
+                    context_parts.append(format_attachment_open_tag(att))
+                    context_parts.append(att.content)
+                    context_parts.append("</attachment>")
+            for skill in self._skills:
+                content = skill.content
+                if len(content) > 4000:
+                    content = content[:4000] + "\n... (truncated)"
+                context_parts.append(f'<skill_content name="{skill.name}">')
+                context_parts.append(content)
+                context_parts.append("</skill_content>")
+            if context_parts:
+                parts.append("<context>\n" + "\n".join(context_parts) + "\n</context>\n")
+
+        if self._previous_messages and not self._resume_session:
+            budget = self._get_history_budget()
+            trimmed = self._trim_to_budget(self._previous_messages, budget)
+            dropped = len(self._previous_messages) - len(trimmed)
+            history_lines = [f"{msg.get('role', 'unknown').capitalize()}: {msg.get('content', '')}" for msg in trimmed]
+            header = "<conversation_history"
+            if dropped > 0:
+                header += f' note="{dropped} older messages omitted for context"'
+            header += ">"
+            parts.append(header + "\n" + "\n\n".join(history_lines) + "\n</conversation_history>\n")
+
+        # Add the task (last user message — earlier user messages are context/history)
+        for msg in reversed(messages):
+            if msg.get("role") == "user":
+                content = msg["content"]
+                if isinstance(content, list):
+                    content = "\n".join(
+                        b if isinstance(b, str) else b.get("text", "")
+                        for b in content
+                        if isinstance(b, str) or b.get("type") == "text"
+                    )
+                parts.append(content)
+                break
+
+        return "\n".join(parts)
+
+    def _get_history_budget(self) -> int:
+        info = self.get_model_info(self._resolved_model) if self._resolved_model else None
+        context_limit = info.max_input_tokens if info else 200_000
+        return context_limit // 2
+
+    @staticmethod
+    def _trim_to_budget(messages: list[dict], budget_tokens: int) -> list[dict]:
+        """Keep the most recent messages that fit within a token budget."""
+        kept = []
+        used = 0
+        for msg in reversed(messages):
+            content = msg.get("content", "")
+            est = len(content) // 4 if isinstance(content, str) else 100
+            if used + est > budget_tokens and kept:
+                break
+            kept.append(msg)
+            used += est
+        kept.reverse()
+        return kept
+
+    async def stop(self) -> None:
+        if self._process:
+            self._session_id = self._process.session_id
+            self._compacted = self._process.compacted
+            await self._process.stop()
+            self._process = None
+            self._turn_count = 0
+
+    def count_tokens(self, text: str, model: str) -> int:
+        return default_count_tokens(text, model)
+
+    def get_model_info(self, model: str) -> ModelInfo | None:
+        resolved = _ALIASES.get(model, model)
+        return _get_model_info(self.name, resolved)
+
+    async def list_models(self) -> list[str]:
+        return list(_ALIASES.keys())
+
+
+def create_provider(name: str = "claude_code", **kwargs: Any) -> ClaudeCodeProvider:
+    return ClaudeCodeProvider(name=name)

tsugite_claude_code-0.17.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: tsugite-claude-code
+Version: 0.17.0
+Summary: Tsugite plugin: Claude Code provider (routes LLM calls through the claude CLI)
+Requires-Python: >=3.11
+Requires-Dist: tsugite-cli==0.17.0

tsugite_claude_code-0.17.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+tsugite_claude_code/__init__.py,sha256=FkOXT_MW0ZqTfcutX9dMOSIGCXXScMkV4arCZPAyvvA,217
+tsugite_claude_code/process.py,sha256=QMCxynuxo8e-nHMyklo85gGjCD5WcD00ymfpnR8oHg4,12761
+tsugite_claude_code/provider.py,sha256=bRfQa1ns5jmYu9spqvYfrpA5K07gVgUWrq917T0hWp8,12290
+tsugite_claude_code-0.17.0.dist-info/METADATA,sha256=rpS35G4dSPSBtv7010YVdnfoGBnRs9UKG9ZqRpqLtWQ,211
+tsugite_claude_code-0.17.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+tsugite_claude_code-0.17.0.dist-info/entry_points.txt,sha256=qm-DoAMQ5y8SP2aLVI2JSWdjuOg5Q-tqjlqIuaqAXj4,70
+tsugite_claude_code-0.17.0.dist-info/RECORD,,

tsugite_claude_code-0.17.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

tsugite_claude_code-0.17.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[tsugite.providers]
+claude_code = tsugite_claude_code:create_provider