evidor 1.10.4.dev1__tar.gz → 1.10.5.dev1__tar.gz

{evidor-1.10.4.dev1 → evidor-1.10.5.dev1}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 <!-- version list -->
 
+## v1.10.5-dev.1 (2026-10-29)
+
+### Bug Fixes
+
+- **anthropic**: Fixing parser and request builder issues
+  ([`5bd9e5d`](https://github.com/vedangiitb/evidor-core/commit/5bd9e5d3a100371ad8656cf097f369cf6cffd469))
+
+- **anthropic**: Fixing streaming issues
+  ([`f8f0267`](https://github.com/vedangiitb/evidor-core/commit/f8f0267bd20a9613dd72aac6a1cd52957a47d106))
+
+
+## v1.10.4 (2026-10-29)
+
+
 ## v1.10.4-dev.1 (2026-10-29)
 
 ### Bug Fixes

{evidor-1.10.4.dev1 → evidor-1.10.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.10.4-dev.1
+Version: 1.10.5-dev.1
 Summary: A small, provider-agnostic harness for LLM input and output.
 Project-URL: Homepage, https://github.com/evidor/evidor-core
 Project-URL: Repository, https://github.com/evidor/evidor-core

{evidor-1.10.4.dev1 → evidor-1.10.5.dev1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "evidor"
-version = "1.10.4-dev.1"
+version = "1.10.5-dev.1"
 description = "A small, provider-agnostic harness for LLM input and output."
 readme = "README.md"
 requires-python = ">=3.10"

evidor-1.10.5.dev1/src/evidor/agent/providers/anthropic/builder.py

@@ -0,0 +1,209 @@
+"""Request payload builder for Anthropic Claude."""
+
+from collections.abc import Sequence
+import json
+from typing import Any
+
+from evidor.models import GenerationRequest, Message
+from ..base import extract_system_prompt, sort_tools
+
+
+class AnthropicPayloadBuilder:
+    """Builds and formats API request payloads for Anthropic's Messages API."""
+
+    def __init__(
+        self,
+        model: str,
+        max_tokens: int,
+        enable_prompt_caching: bool = True,
+        thinking: Any = None,
+        compact_threshold: int | None = None,
+        compact_instructions: str | None = None,
+    ) -> None:
+        self.model = model
+        self.max_tokens = max_tokens
+        self.enable_prompt_caching = enable_prompt_caching
+        self.thinking = thinking
+        self.compact_threshold = compact_threshold
+        self.compact_instructions = compact_instructions
+
+    def build(self, request: GenerationRequest) -> dict[str, Any]:
+        """Construct the full request dictionary for Anthropic Messages API."""
+        system_prompt = extract_system_prompt(request)
+        formatted_messages = self.format_messages(request.messages)
+
+        payload: dict[str, Any] = {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "system": system_prompt or None,
+            "messages": formatted_messages,
+        }
+
+        if self.compact_threshold is not None or self.compact_instructions is not None:
+            edit: dict[str, Any] = {"type": "compact_20260112"}
+            if self.compact_threshold is not None:
+                edit["trigger"] = {"type": "input_tokens", "value": self.compact_threshold}
+            if self.compact_instructions is not None:
+                edit["instructions"] = self.compact_instructions
+            payload["betas"] = ["compact-2026-01-12"]
+            payload["context_management"] = {"edits": [edit]}
+
+        if self.thinking and self.thinking.enabled:
+            if getattr(self.thinking, "type", "enabled") == "adaptive":
+                payload["thinking"] = {"type": "adaptive"}
+                if getattr(self.thinking, "effort", None):
+                    payload["output_config"] = {"effort": self.thinking.effort}
+            else:
+                budget = getattr(self.thinking, "budget_tokens", None)
+                if budget is None or budget < 1024:
+                    budget = 1024
+                payload["thinking"] = {
+                    "type": "enabled",
+                    "budget_tokens": budget,
+                }
+                # Anthropic Messages API requires max_tokens > budget_tokens
+                if payload["max_tokens"] <= budget:
+                    payload["max_tokens"] = budget + 1024
+
+        if self.enable_prompt_caching:
+            payload["cache_control"] = {"type": "ephemeral"}
+
+        if request.tools:
+            sorted_tools = sort_tools(request.tools)
+            payload["tools"] = [self._format_tool(t) for t in sorted_tools]
+
+        return payload
+
+    @staticmethod
+    def _format_tool(tool: Any) -> dict[str, Any]:
+        """Format a tool object or dictionary into an Anthropic tool schema."""
+        if isinstance(tool, dict):
+            name = tool.get("name", "")
+            description = tool.get("description", "")
+            schema = tool.get("input_schema") or tool.get("parameters")
+        else:
+            name = getattr(tool, "name", "")
+            description = getattr(tool, "description", "")
+            schema = getattr(tool, "parameters", None) or getattr(tool, "input_schema", None)
+
+        if not isinstance(schema, dict) or not schema:
+            schema = {"type": "object", "properties": {}}
+
+        tool_dict: dict[str, Any] = {
+            "name": name,
+            "description": description or "",
+            "input_schema": schema,
+        }
+        return tool_dict
+
+    @staticmethod
+    def _normalize_thought_block(tb: Any) -> dict[str, Any] | None:
+        """Convert a thought block (dict, Pydantic model, SDK object) to an Anthropic block dict."""
+        if isinstance(tb, dict):
+            return dict(tb)
+        if hasattr(tb, "model_dump") and callable(tb.model_dump):
+            dumped = tb.model_dump()
+            if isinstance(dumped, dict):
+                return dumped
+        if hasattr(tb, "to_dict") and callable(tb.to_dict):
+            dumped = tb.to_dict()
+            if isinstance(dumped, dict):
+                return dumped
+        if hasattr(tb, "type"):
+            block: dict[str, Any] = {"type": getattr(tb, "type")}
+            if hasattr(tb, "thinking") and getattr(tb, "thinking") is not None:
+                block["thinking"] = getattr(tb, "thinking")
+            if hasattr(tb, "signature") and getattr(tb, "signature") is not None:
+                block["signature"] = getattr(tb, "signature")
+            if hasattr(tb, "data") and getattr(tb, "data") is not None:
+                block["data"] = getattr(tb, "data")
+            return block
+        return None
+
+    def format_messages(self, messages: Sequence[Message]) -> list[dict[str, Any]]:
+        """Format domain messages into Anthropic-compliant message items."""
+        formatted: list[dict[str, Any]] = []
+        for message in messages:
+            if message.role == "system":
+                continue
+
+            if message.role == "tool":
+                tool_use_id = message.tool_call_id or "call_unknown"
+                content_val = (
+                    message.content
+                    if isinstance(message.content, (str, list))
+                    else ("" if message.content is None else json.dumps(message.content))
+                )
+                tool_block: dict[str, Any] = {
+                    "type": "tool_result",
+                    "tool_use_id": tool_use_id,
+                    "content": content_val,
+                }
+                if getattr(message, "is_error", False):
+                    tool_block["is_error"] = True
+
+                if formatted and formatted[-1]["role"] == "user":
+                    prev_content = formatted[-1]["content"]
+                    if isinstance(prev_content, list):
+                        prev_content.append(tool_block)
+                    elif isinstance(prev_content, str):
+                        formatted[-1]["content"] = [
+                            {"type": "text", "text": prev_content},
+                            tool_block,
+                        ]
+                    else:
+                        formatted[-1]["content"] = [tool_block]
+                else:
+                    formatted.append({
+                        "role": "user",
+                        "content": [tool_block],
+                    })
+
+            elif message.role == "assistant":
+                if message.thought_blocks or message.tool_calls or message.compaction:
+                    content_blocks: list[dict[str, Any]] = []
+                    if message.compaction:
+                        content_blocks.append({"type": "compaction", "content": message.compaction})
+                    # Replay thought_blocks with cryptographic signatures if present (must precede text/tools)
+                    if message.thought_blocks:
+                        for tb in message.thought_blocks:
+                            normalized = self._normalize_thought_block(tb)
+                            if normalized is not None:
+                                content_blocks.append(normalized)
+                    if message.content:
+                        content_blocks.append({"type": "text", "text": message.content})
+                    if message.tool_calls:
+                        for tc in message.tool_calls:
+                            content_blocks.append({
+                                "type": "tool_use",
+                                "id": tc.id,
+                                "name": tc.name,
+                                "input": tc.arguments,
+                            })
+                    formatted.append({"role": "assistant", "content": content_blocks})
+                else:
+                    formatted.append({"role": "assistant", "content": message.content})
+
+            else:
+                # User or other role
+                if formatted and formatted[-1]["role"] == "user":
+                    prev_content = formatted[-1]["content"]
+                    if isinstance(prev_content, list):
+                        if isinstance(message.content, list):
+                            prev_content.extend(message.content)
+                        elif message.content:
+                            prev_content.append({"type": "text", "text": message.content})
+                    elif isinstance(prev_content, str):
+                        if isinstance(message.content, str):
+                            formatted[-1]["content"] = f"{prev_content}\n\n{message.content}"
+                        elif isinstance(message.content, list):
+                            formatted[-1]["content"] = [{"type": "text", "text": prev_content}] + list(message.content)
+                        elif message.content:
+                            formatted[-1]["content"] = [
+                                {"type": "text", "text": prev_content},
+                                {"type": "text", "text": str(message.content)},
+                            ]
+                else:
+                    formatted.append({"role": message.role, "content": message.content})
+
+        return formatted

evidor-1.10.5.dev1/src/evidor/agent/providers/anthropic/parser.py

@@ -0,0 +1,178 @@
+"""Response parser for Anthropic Claude."""
+
+from typing import Any
+
+from evidor.models import GenerationResponse, ToolCall
+from ..base import build_token_usage, safe_parse_tool_arguments
+
+
+def _get_field(obj: Any, name: str, default: Any = None) -> Any:
+    """Retrieve an attribute or dict key safely."""
+    if obj is None:
+        return default
+    if isinstance(obj, dict):
+        return obj.get(name, default)
+    return getattr(obj, name, default)
+
+
+class AnthropicResponseParser:
+    """Parses raw Anthropic SDK responses into normalized GenerationResponse objects."""
+
+    def __init__(self, model: str) -> None:
+        self.model = model
+
+    def parse(self, response_msg: Any) -> GenerationResponse:
+        """Parse an Anthropic response object or dict into GenerationResponse."""
+        if response_msg is None:
+            return GenerationResponse(text="", model=self.model)
+
+        raw_id = _get_field(response_msg, "id")
+        msg_id = raw_id if isinstance(raw_id, str) and raw_id.strip() else None
+
+        raw_model = _get_field(response_msg, "model")
+        resp_model = raw_model if isinstance(raw_model, str) and raw_model.strip() else self.model
+
+        raw_content = _get_field(response_msg, "content", [])
+        text, tool_calls, thought_blocks, thought_parts, compaction_summary = self.parse_content_blocks(
+            raw_content
+        )
+
+        thinking_text = "".join(thought_parts) if thought_parts else None
+        if thinking_text is None:
+            raw_thinking = _get_field(response_msg, "thinking") or _get_field(response_msg, "reasoning")
+            if isinstance(raw_thinking, str) and raw_thinking.strip():
+                thinking_text = raw_thinking.strip()
+
+        usage = self.parse_usage(_get_field(response_msg, "usage"))
+
+        return GenerationResponse(
+            id=msg_id,
+            text=text,
+            model=resp_model,
+            tool_calls=tuple(tool_calls),
+            usage=usage,
+            thinking=thinking_text,
+            thought_blocks=tuple(thought_blocks),
+            compaction=compaction_summary,
+        )
+
+    def parse_content_blocks(
+        self, content_blocks: Any
+    ) -> tuple[str, list[ToolCall], list[dict[str, Any]], list[str], str | None]:
+        """Extract text, tools, thoughts, and compaction from response content blocks."""
+        text_parts: list[str] = []
+        thought_parts: list[str] = []
+        thought_blocks: list[dict[str, Any]] = []
+        tool_calls: list[ToolCall] = []
+        compaction_summary: str | None = None
+
+        if not content_blocks:
+            return "", [], [], [], None
+
+        if isinstance(content_blocks, str):
+            return content_blocks, [], [], [], None
+
+        blocks = content_blocks if isinstance(content_blocks, (list, tuple)) else [content_blocks]
+
+        for block in blocks:
+            if isinstance(block, str):
+                text_parts.append(block)
+                continue
+
+            block_type = _get_field(block, "type")
+            if block_type == "text":
+                t = _get_field(block, "text", "")
+                if t:
+                    text_parts.append(str(t))
+            elif block_type == "compaction":
+                c = (
+                    _get_field(block, "content")
+                    or _get_field(block, "text")
+                    or _get_field(block, "summary")
+                    or _get_field(block, "data")
+                )
+                if c:
+                    compaction_summary = str(c)
+            elif block_type == "thinking":
+                th_text = _get_field(block, "thinking") or _get_field(block, "text") or ""
+                thought_parts.append(str(th_text))
+                sig = _get_field(block, "signature")
+                tb: dict[str, Any] = {"type": "thinking", "thinking": str(th_text)}
+                if isinstance(sig, str) and sig.strip():
+                    tb["signature"] = sig.strip()
+                thought_blocks.append(tb)
+            elif block_type == "redacted_thinking":
+                data = _get_field(block, "data")
+                tb_redacted: dict[str, Any] = {"type": "redacted_thinking"}
+                if data is not None and isinstance(data, str):
+                    tb_redacted["data"] = data
+                elif data is not None:
+                    tb_redacted["data"] = str(data)
+                thought_blocks.append(tb_redacted)
+            elif block_type == "tool_use":
+                raw_id = _get_field(block, "id")
+                call_id = raw_id if isinstance(raw_id, str) and raw_id.strip() else f"call_{len(tool_calls)+1}"
+
+                raw_name = _get_field(block, "name")
+                tool_name = raw_name if isinstance(raw_name, str) and raw_name.strip() else "unknown_tool"
+
+                raw_input = _get_field(block, "input")
+                tool_args = safe_parse_tool_arguments(raw_input)
+
+                tool_calls.append(
+                    ToolCall(
+                        id=call_id,
+                        name=tool_name,
+                        arguments=tool_args,
+                    )
+                )
+
+        return "".join(text_parts), tool_calls, thought_blocks, thought_parts, compaction_summary
+
+    def parse_usage(self, raw_usage: Any) -> Any:
+        """Parse token usage statistics from Anthropic raw usage."""
+        if raw_usage is None:
+            return None
+
+        it = _get_field(raw_usage, "input_tokens")
+        ot = _get_field(raw_usage, "output_tokens")
+        raw_cache_read = _get_field(raw_usage, "cache_read_input_tokens")
+        raw_cache_write = _get_field(raw_usage, "cache_creation_input_tokens")
+
+        cache_read = (
+            int(raw_cache_read)
+            if isinstance(raw_cache_read, (int, float)) and not isinstance(raw_cache_read, bool)
+            else 0
+        )
+        cache_write = (
+            int(raw_cache_write)
+            if isinstance(raw_cache_write, (int, float)) and not isinstance(raw_cache_write, bool)
+            else 0
+        )
+
+        reasoning_tokens = 0
+        out_details = _get_field(raw_usage, "output_tokens_details")
+        for candidate in (
+            _get_field(raw_usage, "thinking_tokens"),
+            _get_field(raw_usage, "reasoning_tokens"),
+            _get_field(out_details, "reasoning_tokens"),
+            _get_field(out_details, "thinking_tokens"),
+        ):
+            if isinstance(candidate, (int, float)) and not isinstance(candidate, bool):
+                reasoning_tokens = int(candidate)
+                break
+
+        if not (isinstance(it, int) or isinstance(ot, int)):
+            return None
+
+        prompt_tokens = (int(it) if isinstance(it, int) else 0) + cache_read
+        completion_tokens = int(ot) if isinstance(ot, int) else 0
+
+        return build_token_usage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=prompt_tokens + completion_tokens,
+            cached_tokens=cache_read,
+            cache_creation_tokens=cache_write,
+            reasoning_tokens=reasoning_tokens,
+        )

{evidor-1.10.4.dev1 → evidor-1.10.5.dev1}/src/evidor/agent/providers/anthropic/provider.py

@@ -45,6 +45,7 @@ class AnthropicProvider(BaseProvider):
         thinking: Any = None,
         compact_threshold: int | None = None,
         compact_instructions: str | None = None,
+        base_url: str | None = None,
     ) -> None:
         if thinking is not None:
             from evidor.models import AnthropicThinkingConfig
@@ -62,6 +63,7 @@ class AnthropicProvider(BaseProvider):
         self._enable_prompt_caching = enable_prompt_caching
         self._compact_threshold = compact_threshold
         self._compact_instructions = compact_instructions
+        self._base_url = base_url
         self._sync_client: Any = None
         self._default_async_client: Any = None
         self._async_clients: dict[asyncio.AbstractEventLoop, Any] = {}
@@ -99,6 +101,11 @@ class AnthropicProvider(BaseProvider):
     def compact_instructions(self) -> str | None:
         return self._compact_instructions
 
+    @property
+    def base_url(self) -> str | None:
+        """The custom base URL for Anthropic-compatible endpoints, if configured."""
+        return self._base_url
+
     def with_model(self, model: str) -> "AnthropicProvider":
         return AnthropicProvider(
             model=model,
@@ -108,6 +115,7 @@ class AnthropicProvider(BaseProvider):
             thinking=self._thinking,
             compact_threshold=self._compact_threshold,
             compact_instructions=self._compact_instructions,
+            base_url=self._base_url,
         )
 
     @overload
@@ -163,31 +171,29 @@ class AnthropicProvider(BaseProvider):
     ) -> GenerationResponse | AsyncStreamResponse:
         client = self._get_async_client()
         should_stream = stream or request.stream
-        if client is not None:
-            payload = self._builder.build(request)
-            if should_stream:
-                payload["stream"] = True
-                if self._compact_threshold is not None or self._compact_instructions is not None:
-                    raw_stream = await client.beta.messages.create(**payload)
-                else:
-                    raw_stream = await client.messages.create(**payload)
-                return AsyncStreamResponse(self._create_async_stream(raw_stream))
-
+        payload = self._builder.build(request)
+        if should_stream:
+            payload["stream"] = True
             if self._compact_threshold is not None or self._compact_instructions is not None:
-                response_msg = await client.beta.messages.create(**payload)
+                raw_stream = await client.beta.messages.create(**payload)
             else:
-                response_msg = await client.messages.create(**payload)
-            return self._parser.parse(response_msg)
-        return await asyncio.to_thread(self.generate, request, stream=stream)
+                raw_stream = await client.messages.create(**payload)
+            return AsyncStreamResponse(self._create_async_stream(raw_stream))
+
+        if self._compact_threshold is not None or self._compact_instructions is not None:
+            response_msg = await client.beta.messages.create(**payload)
+        else:
+            response_msg = await client.messages.create(**payload)
+        return self._parser.parse(response_msg)
 
     def _create_stream(self, raw_stream: Any) -> Iterator[StreamChunk]:
-        handler = AnthropicStreamHandler()
+        handler = AnthropicStreamHandler(model=self._model, parser=self._parser)
         for event in raw_stream:
             yield from handler.process_event(event)
         yield from handler.finalize()
 
     async def _create_async_stream(self, raw_stream: Any) -> AsyncIterator[StreamChunk]:
-        handler = AnthropicStreamHandler()
+        handler = AnthropicStreamHandler(model=self._model, parser=self._parser)
         async for event in raw_stream:
             for chunk in handler.process_event(event):
                 yield chunk
@@ -218,23 +224,30 @@ class AnthropicProvider(BaseProvider):
             except ImportError as error:
                 raise ImportError("Install Anthropic support with: pip install 'evidor[anthropic]'") from error
 
-            client = Anthropic(api_key=self._api_key)
+            client_kwargs: dict[str, Any] = {"api_key": self._api_key}
+            if self._base_url is not None:
+                client_kwargs["base_url"] = self._base_url
+            client = Anthropic(**client_kwargs)
             self._sync_client = client
             return client
 
     def _get_async_client(self) -> Any:
         try:
             from anthropic import AsyncAnthropic
-        except (ImportError, AttributeError):
-            return None
+        except (ImportError, AttributeError) as error:
+            raise ImportError("Install Anthropic support with: pip install 'evidor[anthropic]'") from error
 
         if not hasattr(self, "_async_clients"):
             self._async_clients = {}
 
+        client_kwargs: dict[str, Any] = {"api_key": self._api_key}
+        if self._base_url is not None:
+            client_kwargs["base_url"] = self._base_url
+
         client, self._default_async_client = get_or_create_async_client(
             self._async_clients,
             self._default_async_client,
-            lambda: AsyncAnthropic(api_key=self._api_key),
+            lambda: AsyncAnthropic(**client_kwargs),
             self._lock,
         )
         return client
@@ -242,4 +255,3 @@ class AnthropicProvider(BaseProvider):
     # Backward-compatible delegates
     def _format_messages(self, messages: Sequence[Message]) -> list[dict[str, Any]]:
         return self._builder.format_messages(messages)
-