evidor 1.10.3.dev1__tar.gz → 1.10.4.dev1__tar.gz

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

@@ -2,6 +2,26 @@
 
 <!-- version list -->
 
+## v1.10.4-dev.1 (2026-10-29)
+
+### Bug Fixes
+
+- **openai**: Fixing minor issues
+  ([`3cfa475`](https://github.com/vedangiitb/evidor-core/commit/3cfa4750140e293ea8c3d3f94db37fcc332ee9f2))
+
+- **openai**: Fixing request building issues with context compaction and reasoning
+  ([`a8274f5`](https://github.com/vedangiitb/evidor-core/commit/a8274f58267081942b0c0d8c9f187121e05d6834))
+
+- **openai**: Fixing response parsing issues
+  ([`c194b2c`](https://github.com/vedangiitb/evidor-core/commit/c194b2c12932660a896f986cfa83149cf412176b))
+
+- **openai**: Fixing streaming issues
+  ([`644da04`](https://github.com/vedangiitb/evidor-core/commit/644da042fe16e025b24bd15a11ab961720ce4057))
+
+
+## v1.10.3 (2026-10-22)
+
+
 ## v1.10.3-dev.1 (2026-10-22)
 
 ### Bug Fixes

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: evidor
-Version: 1.10.3-dev.1
+Version: 1.10.4-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.3.dev1 → evidor-1.10.4.dev1}/pyproject.toml

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

{evidor-1.10.3.dev1 → evidor-1.10.4.dev1}/src/evidor/agent/providers/openai/builder.py

@@ -32,7 +32,7 @@ class OpenAIPayloadBuilder:
             payload["instructions"] = request.system
         if request.previous_response_id:
             payload["previous_response_id"] = request.previous_response_id
-        if request.conversation_id:
+        elif request.conversation_id:
             payload["conversation"] = request.conversation_id
         if request.store is not None:
             payload["store"] = request.store
@@ -42,13 +42,16 @@ class OpenAIPayloadBuilder:
                 {"type": "compaction", "compact_threshold": self.compact_threshold}
             ]
 
-        if self.thinking and self.thinking.enabled:
+        if self.thinking is not None:
             reasoning_config: dict[str, Any] = {}
-            if self.thinking.effort:
-                reasoning_config["effort"] = self.thinking.effort
-            summary_val = getattr(self.thinking, "summary", None)
-            if summary_val:
-                reasoning_config["summary"] = summary_val
+            if self.thinking.enabled:
+                if self.thinking.effort:
+                    reasoning_config["effort"] = self.thinking.effort
+                summary_val = getattr(self.thinking, "summary", None)
+                if summary_val:
+                    reasoning_config["summary"] = summary_val
+            else:
+                reasoning_config["effort"] = "none"
             if reasoning_config:
                 payload["reasoning"] = reasoning_config
 
@@ -70,23 +73,45 @@ class OpenAIPayloadBuilder:
         """Format domain messages into OpenAI Responses API input items."""
         input_items: list[dict[str, Any]] = []
         for message in messages:
-            if message.role == "tool":
+            if message.compaction:
+                input_items.append({
+                    "type": "compaction",
+                    "encrypted_content": message.compaction,
+                })
+                if message.content:
+                    input_items.append({"role": "assistant", "content": message.content})
+            elif message.role == "tool":
+                output_val = message.content if isinstance(message.content, str) else json.dumps(message.content)
                 input_items.append({
                     "type": "function_call_output",
-                    "call_id": message.tool_call_id,
-                    "output": message.content,
+                    "call_id": message.tool_call_id or "call_unknown",
+                    "output": output_val,
                 })
             elif message.tool_calls:
+                if message.thought_blocks:
+                    for tb in message.thought_blocks:
+                        if isinstance(tb, dict) and tb.get("type") == "reasoning":
+                            input_items.append(tb)
+                if message.content:
+                    input_items.append({"role": "assistant", "content": message.content})
                 for tc in message.tool_calls:
+                    if tc.arguments is None:
+                        args_str = "{}"
+                    elif isinstance(tc.arguments, (dict, list)):
+                        args_str = json.dumps(tc.arguments)
+                    else:
+                        args_str = str(tc.arguments) if str(tc.arguments).strip() else "{}"
                     input_items.append({
                         "type": "function_call",
                         "call_id": tc.id,
                         "name": tc.name,
-                        "arguments": json.dumps(tc.arguments) if isinstance(tc.arguments, dict) else str(tc.arguments),
+                        "arguments": args_str,
                     })
-                if message.content:
-                    input_items.append({"role": "assistant", "content": message.content})
             else:
+                if message.thought_blocks:
+                    for tb in message.thought_blocks:
+                        if isinstance(tb, dict) and tb.get("type") == "reasoning":
+                            input_items.append(tb)
                 input_items.append({"role": message.role, "content": message.content})
         return input_items
 

evidor-1.10.4.dev1/src/evidor/agent/providers/openai/parser.py

@@ -0,0 +1,286 @@
+"""Response parser for OpenAI Responses API."""
+
+from typing import Any, NamedTuple
+
+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)
+
+
+def extract_reasoning_texts(val: Any) -> list[str]:
+    """Extract string snippets from diverse reasoning or thought payload shapes."""
+    if not val:
+        return []
+    if isinstance(val, str):
+        s = val.strip()
+        return [s] if s else []
+    texts: list[str] = []
+    if isinstance(val, (list, tuple)):
+        for item in val:
+            if isinstance(item, str):
+                s = item.strip()
+                if s:
+                    texts.append(s)
+            elif isinstance(item, dict):
+                t = item.get("text") or item.get("content") or item.get("summary")
+                if isinstance(t, str) and t.strip():
+                    texts.append(t.strip())
+            else:
+                t = (
+                    getattr(item, "text", None)
+                    or getattr(item, "content", None)
+                    or getattr(item, "summary", None)
+                )
+                if isinstance(t, str) and t.strip():
+                    texts.append(t.strip())
+    elif isinstance(val, dict):
+        t = val.get("text") or val.get("content") or val.get("summary")
+        if isinstance(t, str) and t.strip():
+            texts.append(t.strip())
+    else:
+        t = (
+            getattr(val, "text", None)
+            or getattr(val, "content", None)
+            or getattr(val, "summary", None)
+        )
+        if isinstance(t, str) and t.strip():
+            texts.append(t.strip())
+    return texts
+
+
+class ParsedOutputItems(NamedTuple):
+    """Structured extraction results from response output items."""
+
+    tool_calls: list[ToolCall]
+    thinking_parts: list[str]
+    compaction: str | None = None
+    text_parts: list[str] = []
+    refusal_parts: list[str] = []
+    thought_blocks: list[Any] = []
+
+
+class OpenAIResponseParser:
+    """Parses raw OpenAI Responses API responses into GenerationResponse objects."""
+
+    def __init__(self, model: str) -> None:
+        self.model = model
+
+    def parse(self, response: Any) -> GenerationResponse:
+        """Parse an OpenAI response object into GenerationResponse."""
+        raw_id = _get_field(response, "id")
+        resp_id = raw_id if isinstance(raw_id, str) else None
+
+        raw_output = _get_field(response, "output")
+        output_items = raw_output if isinstance(raw_output, (list, tuple)) else []
+        parsed = self.parse_output_items(output_items)
+
+        output_text = _get_field(response, "output_text")
+        if isinstance(output_text, str) and output_text:
+            text = output_text
+        elif parsed.text_parts:
+            text = "".join(parsed.text_parts)
+        elif parsed.refusal_parts:
+            text = "\n".join(parsed.refusal_parts)
+        else:
+            text = ""
+
+        thinking_parts = list(parsed.thinking_parts)
+        seen_thinking = set(thinking_parts)
+
+        raw_resp_thinking = _get_field(response, "reasoning") or _get_field(response, "thinking")
+        if isinstance(raw_resp_thinking, str) and raw_resp_thinking.strip():
+            s = raw_resp_thinking.strip()
+            if s not in seen_thinking:
+                seen_thinking.add(s)
+                thinking_parts.append(s)
+        elif raw_resp_thinking is not None:
+            summary_val = _get_field(raw_resp_thinking, "summary")
+            if isinstance(summary_val, (str, list, tuple, dict)):
+                for snippet in extract_reasoning_texts(summary_val):
+                    if snippet not in seen_thinking:
+                        seen_thinking.add(snippet)
+                        thinking_parts.append(snippet)
+
+        thinking_text = "\n".join(thinking_parts) if thinking_parts else None
+        usage = self.parse_usage(_get_field(response, "usage"))
+
+        return GenerationResponse(
+            id=resp_id,
+            text=text,
+            model=self.model,
+            tool_calls=tuple(parsed.tool_calls),
+            usage=usage,
+            thinking=thinking_text,
+            thought_blocks=tuple(parsed.thought_blocks),
+            compaction=parsed.compaction,
+        )
+
+    def parse_output_items(self, output_items: list[Any]) -> ParsedOutputItems:
+        """Extract function calls, reasoning snippets, compaction, text, and refusal from output items."""
+        tool_calls: list[ToolCall] = []
+        thinking_parts: list[str] = []
+        seen_thinking: set[str] = set()
+        compaction_part: str | None = None
+        text_parts: list[str] = []
+        refusal_parts: list[str] = []
+        thought_blocks: list[Any] = []
+
+        if not output_items or not isinstance(output_items, (list, tuple)):
+            return ParsedOutputItems(
+                tool_calls=tool_calls,
+                thinking_parts=thinking_parts,
+                compaction=compaction_part,
+                text_parts=text_parts,
+                refusal_parts=refusal_parts,
+                thought_blocks=thought_blocks,
+            )
+
+        for item in output_items:
+            raw_type = _get_field(item, "type")
+            item_type = raw_type if isinstance(raw_type, str) else None
+            if item_type in ("reasoning", "thought"):
+                thought_blocks.append(item)
+                for attr_name in ("summary", "content", "text"):
+                    val = _get_field(item, attr_name)
+                    if isinstance(val, (str, list, tuple, dict)):
+                        for snippet in extract_reasoning_texts(val):
+                            if snippet not in seen_thinking:
+                                seen_thinking.add(snippet)
+                                thinking_parts.append(snippet)
+            elif item_type in ("function_call", "custom_tool_call"):
+                raw_args = _get_field(item, "arguments")
+                args = (
+                    safe_parse_tool_arguments(raw_args)
+                    if isinstance(raw_args, (str, dict)) or (hasattr(raw_args, "items") and not isinstance(raw_args, type))
+                    else {}
+                )
+                raw_call_id = _get_field(item, "call_id")
+                if not isinstance(raw_call_id, str) or not raw_call_id.strip():
+                    raw_call_id = _get_field(item, "id")
+                call_id = (
+                    raw_call_id.strip()
+                    if isinstance(raw_call_id, str) and raw_call_id.strip()
+                    else f"call_{len(tool_calls)+1}"
+                )
+                raw_name = _get_field(item, "name")
+                name = raw_name if isinstance(raw_name, str) and raw_name.strip() else "tool"
+                tool_calls.append(ToolCall(id=call_id, name=name, arguments=args))
+            elif item_type == "compaction":
+                c = None
+                for attr_name in ("encrypted_content", "content", "text"):
+                    val = _get_field(item, attr_name)
+                    if isinstance(val, str) and val.strip():
+                        c = val.strip()
+                        break
+                if c is None:
+                    for attr_name in ("encrypted_content", "content", "text"):
+                        val = _get_field(item, attr_name)
+                        if val is not None and not isinstance(val, (type, bool)) and type(val).__name__ != "MagicMock":
+                            c = str(val)
+                            break
+                if c:
+                    compaction_part = c
+            elif item_type == "message":
+                contents = _get_field(item, "content")
+                if isinstance(contents, str) and contents.strip():
+                    text_parts.append(contents)
+                elif isinstance(contents, (list, tuple)):
+                    for part in contents:
+                        if isinstance(part, str) and part.strip():
+                            text_parts.append(part)
+                        elif part is not None:
+                            raw_part_type = _get_field(part, "type")
+                            part_type = raw_part_type if isinstance(raw_part_type, str) else None
+                            if part_type == "output_text":
+                                t = _get_field(part, "text")
+                                if isinstance(t, str) and t:
+                                    text_parts.append(t)
+                            elif part_type == "refusal":
+                                r = _get_field(part, "refusal")
+                                if not isinstance(r, str):
+                                    r = _get_field(part, "text")
+                                if isinstance(r, str) and r:
+                                    refusal_parts.append(r)
+                            else:
+                                t = _get_field(part, "text")
+                                if isinstance(t, str) and t:
+                                    text_parts.append(t)
+
+        return ParsedOutputItems(
+            tool_calls=tool_calls,
+            thinking_parts=thinking_parts,
+            compaction=compaction_part,
+            text_parts=text_parts,
+            refusal_parts=refusal_parts,
+            thought_blocks=thought_blocks,
+        )
+
+    def parse_usage(self, raw_usage: Any) -> Any:
+        """Parse token usage statistics from OpenAI Responses API usage."""
+        if raw_usage is None:
+            return None
+
+        pt = _get_field(raw_usage, "prompt_tokens")
+        if not isinstance(pt, int) or isinstance(pt, bool):
+            pt = _get_field(raw_usage, "input_tokens")
+        ct = _get_field(raw_usage, "completion_tokens")
+        if not isinstance(ct, int) or isinstance(ct, bool):
+            ct = _get_field(raw_usage, "output_tokens")
+        tt = _get_field(raw_usage, "total_tokens")
+
+        has_pt = isinstance(pt, int) and not isinstance(pt, bool)
+        has_ct = isinstance(ct, int) and not isinstance(ct, bool)
+        has_tt = isinstance(tt, int) and not isinstance(tt, bool)
+
+        if not (has_pt or has_ct or has_tt):
+            return None
+
+        prompt_tokens = int(pt) if has_pt else 0
+        completion_tokens = int(ct) if has_ct else 0
+
+        cached_tokens = 0
+        cache_creation_tokens = 0
+        pt_details = _get_field(raw_usage, "prompt_tokens_details") or _get_field(raw_usage, "input_tokens_details")
+        if pt_details is not None:
+            raw_cached = _get_field(pt_details, "cached_tokens", 0)
+            if isinstance(raw_cached, int) and not isinstance(raw_cached, bool):
+                cached_tokens = int(raw_cached)
+            if not cached_tokens:
+                raw_hit = _get_field(pt_details, "prompt_cache_hit_tokens", 0)
+                if isinstance(raw_hit, int) and not isinstance(raw_hit, bool):
+                    cached_tokens = int(raw_hit)
+
+            raw_write = _get_field(pt_details, "cache_write_tokens", 0)
+            if not isinstance(raw_write, int) or isinstance(raw_write, bool) or raw_write == 0:
+                raw_write = _get_field(pt_details, "cache_creation_tokens", 0)
+            if isinstance(raw_write, int) and not isinstance(raw_write, bool):
+                cache_creation_tokens = int(raw_write)
+
+        if not cached_tokens:
+            raw_hit = _get_field(raw_usage, "prompt_cache_hit_tokens", 0)
+            if isinstance(raw_hit, int) and not isinstance(raw_hit, bool):
+                cached_tokens = int(raw_hit)
+
+        reasoning_tokens = 0
+        ct_details = _get_field(raw_usage, "completion_tokens_details") or _get_field(raw_usage, "output_tokens_details")
+        if ct_details is not None:
+            raw_reasoning = _get_field(ct_details, "reasoning_tokens", 0)
+            if isinstance(raw_reasoning, int) and not isinstance(raw_reasoning, bool):
+                reasoning_tokens = int(raw_reasoning)
+
+        return build_token_usage(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            total_tokens=int(tt) if has_tt else None,
+            cached_tokens=cached_tokens,
+            reasoning_tokens=reasoning_tokens,
+            cache_creation_tokens=cache_creation_tokens,
+        )

{evidor-1.10.3.dev1 → evidor-1.10.4.dev1}/src/evidor/agent/providers/openai/provider.py

@@ -174,7 +174,7 @@ class OpenAIProvider(BaseProvider):
 
             try:
                 from openai import OpenAI
-            except ImportError as error:
+            except (ImportError, AttributeError) as error:
                 raise ImportError("Install OpenAI support with: pip install 'evidor[openai]'") from error
 
             client_kwargs: dict[str, Any] = {"api_key": self._api_key}
@@ -192,8 +192,8 @@ class OpenAIProvider(BaseProvider):
     def _get_async_client(self) -> Any:
         try:
             from openai import AsyncOpenAI
-        except (ImportError, AttributeError):
-            return None
+        except (ImportError, AttributeError) as error:
+            raise ImportError("Install OpenAI support with: pip install 'evidor[openai]'") from error
 
         if not hasattr(self, "_async_clients"):
             self._async_clients = {}
@@ -210,7 +210,10 @@ class OpenAIProvider(BaseProvider):
         )
 
         if not hasattr(client, "responses") or not hasattr(client.responses, "create"):
-            return None
+            raise RuntimeError(
+                "Modern OpenAI Responses API (client.responses.create) is required. "
+                "Please update openai to the latest version."
+            )
         return client
 
 

evidor-1.10.4.dev1/src/evidor/agent/providers/openai/stream.py

@@ -0,0 +1,128 @@
+"""Streaming event handler for OpenAI Responses API."""
+
+from collections.abc import Iterator
+from typing import Any
+
+from evidor.models import StreamChunk, ToolCall
+from ..base import ToolCallAccumulator
+from .parser import OpenAIResponseParser, _get_field
+
+
+class OpenAIStreamHandler:
+    """Processes OpenAI Responses API stream events into normalized StreamChunk instances."""
+
+    def __init__(self, parser: OpenAIResponseParser) -> None:
+        self.tool_acc = ToolCallAccumulator()
+        self.parser = parser
+        self.item_id_map: dict[str, str] = {}
+
+    def process_event(self, event: Any) -> Iterator[StreamChunk]:
+        """Process a single event from the OpenAI Responses API raw stream."""
+        raw_ev_type = _get_field(event, "type")
+        ev_type = raw_ev_type if isinstance(raw_ev_type, str) else None
+
+        if ev_type in ("response.output_text.delta", "response.text.delta"):
+            delta = _get_field(event, "delta") or ""
+            if delta:
+                yield StreamChunk(text=str(delta), raw_event=event)
+        elif ev_type in ("response.refusal.delta", "response.refusal_text.delta"):
+            delta = _get_field(event, "delta") or ""
+            if delta:
+                yield StreamChunk(text=str(delta), raw_event=event)
+        elif ev_type in ("response.reasoning_text.delta", "response.reasoning_summary_text.delta"):
+            delta = _get_field(event, "delta") or ""
+            if delta:
+                yield StreamChunk(thinking=str(delta), raw_event=event)
+        elif ev_type == "response.output_item.added":
+            item = _get_field(event, "item")
+            item_type = _get_field(item, "type") if item else None
+            if item and item_type in ("function_call", "custom_tool_call"):
+                raw_call_id = _get_field(item, "call_id")
+                raw_item_id = _get_field(item, "id")
+                call_id = (
+                    raw_call_id
+                    if isinstance(raw_call_id, str) and raw_call_id.strip()
+                    else (
+                        raw_item_id
+                        if isinstance(raw_item_id, str) and raw_item_id.strip()
+                        else f"call_{len(self.item_id_map)+1}"
+                    )
+                )
+                if isinstance(raw_item_id, str) and raw_item_id.strip():
+                    self.item_id_map[raw_item_id.strip()] = call_id
+                self.item_id_map[call_id] = call_id
+                name = _get_field(item, "name") or ""
+                self.tool_acc.start_call(call_id, str(name))
+        elif ev_type in (
+            "response.function_call_arguments.delta",
+            "response.custom_tool_call_input_delta",
+        ):
+            delta = _get_field(event, "delta") or ""
+            raw_id = (
+                _get_field(event, "item_id")
+                or _get_field(event, "call_id")
+                or _get_field(event, "id")
+            )
+            call_id = self.item_id_map.get(raw_id, raw_id) if raw_id else "call_1"
+            if delta:
+                self.tool_acc.add_arguments_delta(call_id, str(delta))
+        elif ev_type in (
+            "response.function_call_arguments.done",
+            "response.custom_tool_call_input_done",
+            "response.output_item.done",
+        ):
+            item = _get_field(event, "item")
+            raw_id = (
+                _get_field(item, "call_id")
+                or _get_field(item, "id")
+                or _get_field(event, "item_id")
+                or _get_field(event, "call_id")
+            )
+            call_id = self.item_id_map.get(raw_id, raw_id) if raw_id else None
+            if call_id and call_id in self.tool_acc._calls:
+                event_args = _get_field(event, "arguments") or _get_field(item, "arguments")
+                if event_args and not self.tool_acc._calls[call_id]["args_parts"]:
+                    self.tool_acc.add_arguments_delta(call_id, str(event_args))
+                item_name = _get_field(item, "name")
+                if item_name and not self.tool_acc._calls[call_id]["name"]:
+                    self.tool_acc._calls[call_id]["name"] = str(item_name)
+
+                tc = self.tool_acc.complete_call(call_id)
+                if tc:
+                    yield StreamChunk(tool_calls=(tc,), raw_event=event)
+        elif ev_type in ("response.error", "error"):
+            err_msg = _get_field(event, "message")
+            if not err_msg:
+                err_obj = _get_field(event, "error")
+                err_msg = _get_field(err_obj, "message") if err_obj else None
+            err_code = _get_field(event, "code")
+            full_msg = (
+                f"OpenAI stream error ({err_code}): {err_msg}"
+                if err_code
+                else f"OpenAI stream error: {err_msg or 'unknown error'}"
+            )
+            raise RuntimeError(full_msg)
+        elif ev_type == "response.failed":
+            resp = _get_field(event, "response")
+            err_obj = _get_field(resp, "error") if resp else None
+            err_msg = _get_field(err_obj, "message") if err_obj else None
+            err_code = _get_field(err_obj, "code") if err_obj else None
+            full_msg = (
+                f"OpenAI response failed ({err_code}): {err_msg}"
+                if err_code
+                else f"OpenAI response failed: {err_msg or 'unknown failure'}"
+            )
+            raise RuntimeError(full_msg)
+        elif ev_type == "response.completed":
+            final_resp = self.parser.parse(_get_field(event, "response"))
+            yield StreamChunk(is_finished=True, response=final_resp, raw_event=event)
+
+    def finalize(self) -> Iterator[StreamChunk]:
+        """Yield any in-flight accumulated tool calls at the end of the stream."""
+        in_flight: list[ToolCall] = []
+        for call_id in list(self.tool_acc._calls.keys()):
+            tc = self.tool_acc.complete_call(call_id)
+            if tc is not None:
+                in_flight.append(tc)
+        if in_flight:
+            yield StreamChunk(tool_calls=tuple(in_flight))