deepstrike 0.2.7__tar.gz → 0.2.8__tar.gz

{deepstrike-0.2.7 → deepstrike-0.2.8}/Cargo.lock

@@ -194,7 +194,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-core"
-version = "0.2.7"
+version = "0.2.8"
 dependencies = [
  "compact_str",
  "pretty_assertions",
@@ -206,7 +206,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-node"
-version = "0.2.7"
+version = "0.2.8"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -218,7 +218,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-py"
-version = "0.2.7"
+version = "0.2.8"
 dependencies = [
  "compact_str",
  "deepstrike-core",
@@ -229,7 +229,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-sdk"
-version = "0.2.7"
+version = "0.2.8"
 dependencies = [
  "async-stream",
  "async-trait",
@@ -263,7 +263,7 @@ dependencies = [
 
 [[package]]
 name = "deepstrike-wasm"
-version = "0.2.7"
+version = "0.2.8"
 dependencies = [
  "compact_str",
  "deepstrike-core",

{deepstrike-0.2.7 → deepstrike-0.2.8}/Cargo.toml

@@ -3,13 +3,13 @@ resolver = "2"
 members = ["crates/deepstrike-core", "crates/deepstrike-py"]
 
 [workspace.package]
-version = "0.2.7"
+version = "0.2.8"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/kongusen/deepstrike"
 
 [workspace.dependencies]
-deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.7" }
+deepstrike-core = { path = "crates/deepstrike-core", version = "0.2.8" }
 notify = "6"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"

{deepstrike-0.2.7 → deepstrike-0.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: deepstrike
-Version: 0.2.7
+Version: 0.2.8
 Requires-Dist: httpx>=0.27
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: anyio>=4.0

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/__init__.py

@@ -31,6 +31,12 @@ from .stream import (
     ToolArgumentRepairedEvent,
 )
 from .replay import ReasoningReplayMixin, assistant_replay_key
+from .replay_validator import (
+    DEGRADED_REASONING_PLACEHOLDER,
+    ProviderReplayValidationError,
+    assess_reasoning_replay,
+    validate_openai_chat_replay,
+)
 from .anthropic import AnthropicProvider
 from .openai import OpenAIProvider
 from .qwen import QwenProvider
@@ -49,6 +55,8 @@ __all__ = [
     "to_anthropic_content", "to_anthropic_messages",
     "to_openai_content", "to_openai_message_params", "ThinkingTagStreamExtractor",
     "ReasoningReplayMixin", "assistant_replay_key",
+    "ProviderReplayValidationError", "validate_openai_chat_replay", "assess_reasoning_replay",
+    "DEGRADED_REASONING_PLACEHOLDER",
     "StreamEvent", "TextDelta", "ThinkingDelta",
     "ToolCallEvent", "ToolDeltaEvent", "ToolSuspendEvent", "ToolResultEvent", "DoneEvent", "ErrorEvent",
     "PermissionRequestEvent", "PermissionResolvedEvent", "PermissionResponse",

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/base.py

@@ -11,6 +11,20 @@ from .stream import StreamEvent
 logger = logging.getLogger(__name__)
 T = TypeVar("T")
 
+# Internal control flags that steer DeepStrike's own serialization/validation
+# and must never be forwarded to any provider's wire request.
+INTERNAL_EXTENSION_KEYS = frozenset({"degrade_missing_reasoning_replay"})
+
+# Keys the chat-completions transport sets itself; never echo them from extensions.
+_WIRE_RESERVED_KEYS = frozenset({"model", "messages", "tools", "stream", "stream_options"})
+
+
+def wire_request_extensions(extensions: dict | None, *, extra_omit: tuple[str, ...] = ()) -> dict:
+    """Filter caller extensions down to what is safe to send on the wire,
+    dropping transport-reserved keys and DeepStrike-internal control flags."""
+    blocked = _WIRE_RESERVED_KEYS | INTERNAL_EXTENSION_KEYS | frozenset(extra_omit)
+    return {k: v for k, v in (extensions or {}).items() if k not in blocked}
+
 
 def parse_tool_arguments(value: Any) -> dict[str, Any]:
     """Normalize tool arguments to dict, handling str/dict/null."""

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/deepseek.py

@@ -5,7 +5,7 @@ from typing import AsyncIterator
 import httpx
 from deepstrike._kernel import Message, ToolCall, ToolSchema
 from .stream import StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent
-from .base import RetryConfig, ProviderDescriptor, RenderedContext, RuntimePolicy, normalize_tool_call
+from .base import RetryConfig, ProviderDescriptor, RenderedContext, RuntimePolicy, normalize_tool_call, wire_request_extensions
 from .openai import OpenAIProvider
 
 logger = logging.getLogger(__name__)
@@ -90,7 +90,7 @@ class DeepSeekProvider(OpenAIProvider):
         last_exc = None
         for attempt in range(self._retry.max_retries):
             try:
-                request_extensions = {k: v for k, v in (extensions or {}).items() if k not in {"model", "messages", "tools", "stream", "stream_options"}}
+                request_extensions = wire_request_extensions(extensions)
                 resp = await self._client.chat.completions.create(
                     **request_extensions,
                     model=self._model,

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/minimax.py

@@ -5,7 +5,7 @@ from typing import AsyncIterator
 
 from deepstrike._kernel import Message, ToolCall, ToolSchema
 from .anthropic import AnthropicProvider
-from .base import ProviderDescriptor, RenderedContext, RetryConfig, RuntimePolicy, normalize_tool_call
+from .base import ProviderDescriptor, RenderedContext, RetryConfig, RuntimePolicy, normalize_tool_call, wire_request_extensions
 from .openai import OpenAIProvider
 from .stream import StreamEvent, TextDelta, ThinkingDelta, ToolCallEvent, UsageEvent
 
@@ -119,7 +119,7 @@ class MiniMaxOpenAIProvider(OpenAIProvider):
         last_exc = None
         for attempt in range(self._retry.max_retries):
             try:
-                request_extensions = {k: v for k, v in ext.items() if k not in {"model", "messages", "tools", "stream", "stream_options"}}
+                request_extensions = wire_request_extensions(ext)
                 resp = await self._client.chat.completions.create(
                     **request_extensions,
                     model=self._model,

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/openai.py

@@ -5,7 +5,7 @@ from typing import AsyncIterator
 from openai import AsyncOpenAI
 from deepstrike._kernel import Message, ToolCall, ToolSchema
 from .stream import StreamEvent, TextDelta, ToolCallEvent, ThinkingDelta
-from .base import RetryConfig, CircuitBreaker, ProviderDescriptor, RenderedContext, RuntimePolicy, normalize_tool_call, to_openai_message_params, ThinkingTagStreamExtractor
+from .base import RetryConfig, CircuitBreaker, ProviderDescriptor, RenderedContext, RuntimePolicy, normalize_tool_call, to_openai_message_params, ThinkingTagStreamExtractor, wire_request_extensions
 from .replay import ReasoningReplayMixin, assistant_replay_key
 from .replay_validator import validate_openai_chat_replay
 
@@ -66,17 +66,35 @@ class OpenAIProvider(ReasoningReplayMixin):
     def _require_non_empty_reasoning_replay_for_tool_turns(self, extensions: dict | None) -> bool:
         return False
 
+    def _degrade_missing_reasoning_replay(self, extensions: dict | None) -> bool:
+        return (extensions or {}).get("degrade_missing_reasoning_replay") is True
+
+    def assess_replayability(self, context: RenderedContext, extensions: dict | None = None) -> dict:
+        """Pre-flight query: would this history validate against this provider with
+        the given extensions, without sending the request? Returns the tool-call
+        ids whose turn lacks the reasoning replay this provider requires, so an
+        embedder can route around the failure before issuing the request. Seed any
+        persisted replay first. ``ok`` is True when no reasoning replay is required."""
+        if not self._require_non_empty_reasoning_replay_for_tool_turns(extensions):
+            return {"ok": True, "offending_call_ids": []}
+        return self.assess_reasoning(context)
+
     def _build_messages(self, context: RenderedContext, extensions: dict | None = None) -> list[dict]:
+        require_reasoning = self._require_non_empty_reasoning_replay_for_tool_turns(extensions)
+        degrade = self._degrade_missing_reasoning_replay(extensions)
         validate_openai_chat_replay(
             context.turns,
             descriptor=self.descriptor(),
-            require_non_empty_reasoning_for_tool_calls=self._require_non_empty_reasoning_replay_for_tool_turns(extensions),
+            require_non_empty_reasoning_for_tool_calls=require_reasoning,
+            degrade_missing_reasoning=degrade,
             replay_for_assistant=lambda content, tool_calls: self._replay_fields.get(
                 assistant_replay_key(content, tool_calls)
             ),
         )
         serialized = to_openai_message_params(context)
-        return self._merge_replay_into_openai_messages(serialized, context)
+        return self._merge_replay_into_openai_messages(
+            serialized, context, degrade_missing_reasoning=require_reasoning and degrade,
+        )
 
     def _build_tools(self, tools: list[ToolSchema]) -> list[dict] | None:
         if not tools:
@@ -107,11 +125,7 @@ class OpenAIProvider(ReasoningReplayMixin):
         extensions: dict | None = None,
     ) -> dict:
         body = {
-            **{
-                k: v
-                for k, v in (extensions or {}).items()
-                if k not in {"model", "messages", "tools", "stream", "stream_options"}
-            },
+            **wire_request_extensions(extensions),
             "model": self._model,
             "messages": messages,
             "stream": stream,
@@ -131,7 +145,7 @@ class OpenAIProvider(ReasoningReplayMixin):
         last_exc = None
         for attempt in range(self._retry.max_retries):
             try:
-                request_extensions = {k: v for k, v in (extensions or {}).items() if k not in {"model", "messages", "tools", "stream", "stream_options"}}
+                request_extensions = wire_request_extensions(extensions)
                 resp = await self._client.chat.completions.create(
                     **request_extensions,
                     model=self._model,
@@ -175,7 +189,7 @@ class OpenAIProvider(ReasoningReplayMixin):
         accumulated_content = ""
         final_tool_calls = []
 
-        request_extensions = {k: v for k, v in (extensions or {}).items() if k not in {"model", "messages", "tools", "stream", "stream_options"}}
+        request_extensions = wire_request_extensions(extensions)
         stream = await self._client.chat.completions.create(
             **request_extensions,
             model=self._model,

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/replay.py

@@ -6,6 +6,7 @@ from typing import Any
 from deepstrike._kernel import Message, ToolCall
 
 from .base import RenderedContext
+from .replay_validator import DEGRADED_REASONING_PLACEHOLDER, assess_reasoning_replay
 
 
 def _sort_dict_keys(val: Any) -> Any:
@@ -83,6 +84,7 @@ class ReasoningReplayMixin:
         self,
         serialized: list[dict[str, Any]],
         context: RenderedContext,
+        degrade_missing_reasoning: bool = False,
     ) -> list[dict[str, Any]]:
         cursor = 1 if context.system_text else 0
         for source in context.turns:
@@ -97,11 +99,27 @@ class ReasoningReplayMixin:
                     assistant_replay_key(source.content, source.tool_calls or [])
                 )
                 wire = openai_chat_wire_replay_fields(replay)
+                if not wire and degrade_missing_reasoning and source.tool_calls:
+                    # Reasoning-requiring provider, no stored reasoning for this
+                    # tool-call turn, caller opted into degradation: inject a
+                    # placeholder so the wire message stays well-formed instead of
+                    # failing the whole request.
+                    wire = {"reasoning_content": DEGRADED_REASONING_PLACEHOLDER}
                 if wire:
                     serialized[cursor] = {**serialized[cursor], **wire}
             cursor += 1
         return serialized
 
+    def assess_reasoning(self, context: RenderedContext) -> dict:
+        """Raise-free pre-flight check: which assistant tool-call turns in
+        ``context`` lack the non-empty reasoning replay this provider needs."""
+        return assess_reasoning_replay(
+            context.turns,
+            lambda content, tool_calls: self._replay_fields.get(
+                assistant_replay_key(content, tool_calls)
+            ),
+        )
+
     def remember_reasoning_for_turn(
         self,
         content: str,

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/providers/replay_validator.py

@@ -4,6 +4,12 @@ from typing import Any, Callable
 
 from deepstrike._kernel import Message
 
+# Placeholder reasoning injected for an assistant tool-call turn that has no
+# stored reasoning replay when the caller opted into graceful degradation
+# (``degrade_missing_reasoning``). Keeps the wire message well-formed for a
+# thinking-on provider without fabricating substantive reasoning.
+DEGRADED_REASONING_PLACEHOLDER = "[reasoning unavailable on replay]"
+
 
 class ProviderReplayValidationError(Exception):
     """Raised before dispatch when a rebuilt history would violate the
@@ -15,11 +21,42 @@ def validate_openai_chat_replay(
     *,
     descriptor: Any = None,
     require_non_empty_reasoning_for_tool_calls: bool = False,
+    degrade_missing_reasoning: bool = False,
     replay_for_assistant: Callable[[str, list], dict | None] | None = None,
 ) -> None:
     _validate_strict_tool_result_pairing(turns)
-    if require_non_empty_reasoning_for_tool_calls:
-        _validate_reasoning_replay_for_assistant_tool_calls(turns, descriptor, replay_for_assistant)
+    if require_non_empty_reasoning_for_tool_calls and not degrade_missing_reasoning:
+        assessment = assess_reasoning_replay(turns, replay_for_assistant)
+        if not assessment["ok"]:
+            raise _reasoning_replay_error(assessment["offending_call_ids"], descriptor)
+
+
+def assess_reasoning_replay(
+    turns: list[Message],
+    replay_for_assistant: Callable[[str, list], dict | None] | None,
+) -> dict:
+    """Pure, raise-free assessment: which assistant tool-call turns lack the
+    non-empty reasoning replay a reasoning-requiring provider needs. Lets an
+    embedder decide per-candidate whether to keep thinking on, disable it, or
+    skip the candidate — before sending."""
+    offending_call_ids: list[str] = []
+    for message in turns:
+        if message.role != "assistant" or not getattr(message, "tool_calls", None):
+            continue
+        replay = replay_for_assistant(message.content, message.tool_calls) if replay_for_assistant else None
+        reasoning = replay.get("reasoning_content") if isinstance(replay, dict) else None
+        if not (isinstance(reasoning, str) and reasoning.strip()):
+            offending_call_ids.extend(tc.id for tc in message.tool_calls)
+    return {"ok": not offending_call_ids, "offending_call_ids": offending_call_ids}
+
+
+def _reasoning_replay_error(call_ids: list[str], descriptor: Any) -> ProviderReplayValidationError:
+    who = f"{descriptor.provider}/{descriptor.model}" if descriptor is not None else "provider"
+    return ProviderReplayValidationError(
+        f"{who} replay requires non-empty reasoning_content for assistant tool call turn {', '.join(call_ids)}. "
+        "Disable thinking, rebuild this history with provider replay, switch to a provider that can replay this turn, "
+        "or pass extensions['degrade_missing_reasoning_replay'] to send a degraded turn."
+    )
 
 
 def _tool_result_parts(message: Message) -> list:
@@ -30,14 +67,26 @@ def _validate_strict_tool_result_pairing(turns: list[Message]) -> None:
     pending_ids: set[str] | None = None
     completed_ids: set[str] = set()
 
+    def assert_all_completed() -> None:
+        if not pending_ids:
+            return
+        missing = [cid for cid in pending_ids if cid not in completed_ids]
+        if missing:
+            raise ProviderReplayValidationError(
+                f"OpenAI-compatible replay has assistant tool_calls with no tool result for {', '.join(missing)}: "
+                "every tool_call must be answered by a tool message before the next assistant or user turn."
+            )
+
     for message in turns:
         if message.role == "assistant":
+            assert_all_completed()
             tool_calls = getattr(message, "tool_calls", None) or []
             pending_ids = {tc.id for tc in tool_calls} if tool_calls else None
             completed_ids = set()
             continue
 
         if message.role != "tool":
+            assert_all_completed()
             pending_ids = None
             completed_ids = set()
             continue
@@ -54,22 +103,4 @@ def _validate_strict_tool_result_pairing(turns: list[Message]) -> None:
                 )
             completed_ids.add(part.call_id)
 
-
-def _validate_reasoning_replay_for_assistant_tool_calls(
-    turns: list[Message],
-    descriptor: Any,
-    replay_for_assistant: Callable[[str, list], dict | None] | None,
-) -> None:
-    for message in turns:
-        if message.role != "assistant" or not getattr(message, "tool_calls", None):
-            continue
-        replay = replay_for_assistant(message.content, message.tool_calls) if replay_for_assistant else None
-        reasoning = replay.get("reasoning_content") if isinstance(replay, dict) else None
-        if not (isinstance(reasoning, str) and reasoning.strip()):
-            call_ids = ", ".join(tc.id for tc in message.tool_calls)
-            who = f"{descriptor.provider}/{descriptor.model}" if descriptor is not None else "provider"
-            raise ProviderReplayValidationError(
-                f"{who} replay requires non-empty reasoning_content for assistant tool call turn {call_ids}. "
-                "Disable thinking, rebuild this history with provider replay, or switch to a provider "
-                "that can replay this turn."
-            )
+    assert_all_completed()

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/runtime/__init__.py

@@ -18,7 +18,9 @@ from deepstrike.runtime.session_log import (
 )
 from deepstrike.runtime.provider_replay import (
   ProviderReplay,
+  assess_provider_replayability,
   assistant_replay_key,
+  is_replay_compatible_with_provider,
   peek_provider_replay,
   seed_provider_replay_from_events,
 )
@@ -65,6 +67,8 @@ __all__ = [
   "assistant_replay_key",
   "peek_provider_replay",
   "seed_provider_replay_from_events",
+  "assess_provider_replayability",
+  "is_replay_compatible_with_provider",
   "CredentialVault",
   "EnvCredentialVault",
   "InMemoryCredentialVault",

{deepstrike-0.2.7 → deepstrike-0.2.8}/deepstrike/runtime/provider_replay.py

@@ -11,6 +11,7 @@ __all__ = [
     "is_replay_compatible_with_provider",
     "seed_provider_replay_from_events",
     "peek_provider_replay",
+    "assess_provider_replayability",
 ]
 
 class ProviderReplay(TypedDict, total=False):
@@ -77,3 +78,15 @@ def peek_provider_replay(provider: Any, content: str, tool_calls: list[ToolCall]
     if not callable(peek):
         return None
     return peek(content, tool_calls)
+
+
+def assess_provider_replayability(provider: Any, context: Any, extensions: dict | None = None) -> dict:
+    """Pre-flight query for fallback routing: would ``context`` validate against
+    ``provider`` (with ``extensions``) before the request is sent? Seed any
+    persisted replay first so the assessment reflects what the provider can
+    actually replay. Providers without ``assess_replayability`` (no reasoning-
+    replay requirement) are reported as ``ok``."""
+    assess = getattr(provider, "assess_replayability", None)
+    if not callable(assess):
+        return {"ok": True, "offending_call_ids": []}
+    return assess(context, extensions)

{deepstrike-0.2.7 → deepstrike-0.2.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "deepstrike"
-version = "0.2.7"
+version = "0.2.8"
 requires-python = ">=3.10"
 readme = "README.md"
 dependencies = [