mirascope 2.0.0a6__py3-none-any.whl → 2.0.1__py3-none-any.whl

mirascope/llm/providers/openai/responses/_utils/encode.py

@@ -1,7 +1,9 @@
 """OpenAI Responses message encoding and request preparation."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
-from typing import TypedDict, cast
+from typing import TYPE_CHECKING, TypedDict, cast
 
 from openai import Omit
 from openai.types.responses import (
@@ -33,11 +35,12 @@ from .....exceptions import FeatureNotSupportedError
 from .....formatting import (
     Format,
     FormattableT,
+    OutputParser,
     resolve_format,
 )
 from .....messages import AssistantMessage, Message, UserMessage
 from .....tools import FORMAT_TOOL_NAME, AnyToolSchema, BaseToolkit
-from ....base import Params, ThinkingLevel, _utils as _base_utils
+from ....base import _utils as _base_utils
 from ...model_id import OpenAIModelId, model_name
 from ...model_info import (
     MODELS_WITHOUT_JSON_OBJECT_SUPPORT,
@@ -45,6 +48,9 @@ from ...model_info import (
     NON_REASONING_MODELS,
 )
 
+if TYPE_CHECKING:
+    from .....models import Params, ThinkingLevel
+
 # Thinking level to a float multiplier % of max tokens
 THINKING_LEVEL_TO_EFFORT: dict[ThinkingLevel, ReasoningEffort] = {
     "default": "medium",
@@ -113,7 +119,7 @@ def _encode_user_message(
             result.append(
                 FunctionCallOutput(
                     call_id=part.id,
-                    output=str(part.value),
+                    output=str(part.result),
                     type="function_call_output",
                 )
             )
@@ -211,13 +217,16 @@ def _convert_tool_to_function_tool_param(tool: AnyToolSchema) -> FunctionToolPar
     schema_dict = tool.parameters.model_dump(by_alias=True, exclude_none=True)
     schema_dict["type"] = "object"
     _base_utils.ensure_additional_properties_false(schema_dict)
+    strict = True if tool.strict is None else tool.strict
+    if strict:
+        _base_utils.ensure_all_properties_required(schema_dict)
 
     return FunctionToolParam(
         type="function",
         name=tool.name,
         description=tool.description,
         parameters=schema_dict,
-        strict=tool.strict,
+        strict=strict,
     )
 
 
@@ -249,20 +258,20 @@ def _create_strict_response_format(
 
 def _compute_reasoning(
     level: ThinkingLevel,
-    include_summaries: bool,
+    include_thoughts: bool,
 ) -> Reasoning:
     """Compute the OpenAI `Reasoning` config based on ThinkingConfig.
 
     Args:
         level: The thinking level
-        include_summaries: Whether to include summary (True/False for auto)
+        include_thoughts: Whether to include summary (True/False for auto)
 
     Returns:
         OpenAI Reasoning configuration
     """
     reasoning: Reasoning = {"effort": THINKING_LEVEL_TO_EFFORT.get(level) or "medium"}
 
-    if include_summaries:
+    if include_thoughts:
         reasoning["summary"] = "auto"
 
     return reasoning
@@ -273,7 +282,10 @@ def encode_request(
     model_id: OpenAIModelId,
     messages: Sequence[Message],
     tools: Sequence[AnyToolSchema] | BaseToolkit[AnyToolSchema] | None,
-    format: type[FormattableT] | Format[FormattableT] | None,
+    format: type[FormattableT]
+    | Format[FormattableT]
+    | OutputParser[FormattableT]
+    | None,
     params: Params,
 ) -> tuple[Sequence[Message], Format[FormattableT] | None, ResponseCreateKwargs]:
     """Prepares a request for the `OpenAI.responses.create` method."""
@@ -315,8 +327,8 @@ def encode_request(
                 # Assume model supports reasoning unless explicitly listed as non-reasoning
                 # This ensures new reasoning models work immediately without code updates
                 level = thinking_config.get("level")
-                include_summaries = thinking_config.get("include_summaries", True)
-                kwargs["reasoning"] = _compute_reasoning(level, include_summaries)
+                include_thoughts = thinking_config.get("include_thoughts", False)
+                kwargs["reasoning"] = _compute_reasoning(level, include_thoughts)
 
             # Handle encode_thoughts_as_text from ThinkingConfig
             if thinking_config.get("encode_thoughts_as_text"):

mirascope/llm/providers/openai/responses/provider.py

@@ -1,13 +1,16 @@
 """OpenAI Responses API client implementation."""
 
+from __future__ import annotations
+
 from collections.abc import Sequence
+from typing import TYPE_CHECKING
 from typing_extensions import Unpack
 
 from openai import AsyncOpenAI, BadRequestError as OpenAIBadRequestError, OpenAI
 
 from ....context import Context, DepsT
 from ....exceptions import BadRequestError, NotFoundError
-from ....formatting import Format, FormattableT
+from ....formatting import Format, FormattableT, OutputParser
 from ....messages import Message
 from ....responses import (
     AsyncContextResponse,
@@ -29,11 +32,14 @@ from ....tools import (
     Tool,
     Toolkit,
 )
-from ...base import BaseProvider, Params
+from ...base import BaseProvider
 from .. import _utils as _shared_utils
 from ..model_id import OpenAIModelId, model_name
 from . import _utils
 
+if TYPE_CHECKING:
+    from ....models import Params
+
 
 class OpenAIResponsesProvider(BaseProvider[OpenAI]):
     """The client for the OpenAI Responses API."""
@@ -67,7 +73,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> Response | Response[FormattableT]:
         """Generate an `llm.Response` by synchronously calling the OpenAI Responses API.
@@ -91,8 +100,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = self.client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -116,7 +126,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> AsyncResponse | AsyncResponse[FormattableT]:
         """Generate an `llm.AsyncResponse` by asynchronously calling the OpenAI Responses API.
@@ -140,8 +153,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = await self.async_client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -165,7 +179,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[Tool] | Toolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> StreamResponse | StreamResponse[FormattableT]:
         """Generate a `llm.StreamResponse` by synchronously streaming from the OpenAI Responses API.
@@ -192,8 +209,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -214,7 +232,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         model_id: OpenAIModelId,
         messages: Sequence[Message],
         tools: Sequence[AsyncTool] | AsyncToolkit | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> AsyncStreamResponse | AsyncStreamResponse[FormattableT]:
         """Generate a `llm.AsyncStreamResponse` by asynchronously streaming from the OpenAI Responses API.
@@ -241,8 +262,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_async_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -266,7 +288,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> ContextResponse[DepsT] | ContextResponse[DepsT, FormattableT]:
         """Generate a `llm.ContextResponse` by synchronously calling the OpenAI Responses API with context.
@@ -291,8 +316,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = self.client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -319,7 +345,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> AsyncContextResponse[DepsT] | AsyncContextResponse[DepsT, FormattableT]:
         """Generate a `llm.AsyncContextResponse` by asynchronously calling the OpenAI Responses API with context.
@@ -344,8 +373,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         )
         openai_response = await self.async_client.responses.create(**kwargs)
 
+        include_thoughts = _utils.get_include_thoughts(params)
         assistant_message, finish_reason, usage = _utils.decode_response(
-            openai_response, model_id, self.id
+            openai_response, model_id, self.id, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -372,7 +402,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[Tool | ContextTool[DepsT]]
         | ContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> ContextStreamResponse[DepsT] | ContextStreamResponse[DepsT, FormattableT]:
         """Generate a `llm.ContextStreamResponse` by synchronously streaming from the OpenAI Responses API with context.
@@ -401,8 +434,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 
@@ -426,7 +460,10 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
         tools: Sequence[AsyncTool | AsyncContextTool[DepsT]]
         | AsyncContextToolkit[DepsT]
         | None = None,
-        format: type[FormattableT] | Format[FormattableT] | None = None,
+        format: type[FormattableT]
+        | Format[FormattableT]
+        | OutputParser[FormattableT]
+        | None = None,
         **params: Unpack[Params],
     ) -> (
         AsyncContextStreamResponse[DepsT]
@@ -458,8 +495,9 @@ class OpenAIResponsesProvider(BaseProvider[OpenAI]):
             stream=True,
         )
 
+        include_thoughts = _utils.get_include_thoughts(params)
         chunk_iterator = _utils.decode_async_stream(
-            openai_stream,
+            openai_stream, include_thoughts=include_thoughts
         )
         provider_model_name = model_name(model_id, "responses")
 

mirascope/llm/providers/provider_registry.py

@@ -1,9 +1,12 @@
 """Provider registry for managing provider instances and scopes."""
 
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass
 from functools import lru_cache
 from typing import overload
 
-from ..exceptions import NoRegisteredProviderError
+from ..exceptions import MissingAPIKeyError, NoRegisteredProviderError
 from .anthropic import AnthropicProvider
 from .base import Provider
 from .google import GoogleProvider
@@ -27,18 +30,64 @@ def reset_provider_registry() -> None:
     provider_singleton.cache_clear()
 
 
-# Default auto-registration mapping for built-in providers
-# These providers will be automatically registered on first use
-DEFAULT_AUTO_REGISTER_SCOPES: dict[str, ProviderId] = {
-    "anthropic/": "anthropic",
-    "google/": "google",
-    "mlx-community/": "mlx",
-    "ollama/": "ollama",
-    "openai/": "openai",
-    "together/": "together",
+@dataclass(frozen=True)
+class ProviderDefault:
+    """Configuration for a provider in the auto-registration fallback chain.
+
+    When auto-registering a provider for a scope, the fallback chain is tried
+    in order. The first provider whose API key is available will be used.
+    """
+
+    provider_id: ProviderId
+    """The provider identifier."""
+
+    api_key_env_var: str | None
+    """Environment variable for the API key, or None if no key is required."""
+
+
+# Fallback chain for auto-registration: try providers in order until one has
+# its API key available. This enables automatic fallback to Mirascope Router
+# when direct provider keys are not set.
+DEFAULT_AUTO_REGISTER_SCOPES: dict[str, Sequence[ProviderDefault]] = {
+    "anthropic/": [
+        ProviderDefault("anthropic", "ANTHROPIC_API_KEY"),
+        ProviderDefault("mirascope", "MIRASCOPE_API_KEY"),
+    ],
+    "google/": [
+        ProviderDefault("google", "GOOGLE_API_KEY"),
+        ProviderDefault("mirascope", "MIRASCOPE_API_KEY"),
+    ],
+    "openai/": [
+        ProviderDefault("openai", "OPENAI_API_KEY"),
+        ProviderDefault("mirascope", "MIRASCOPE_API_KEY"),
+    ],
+    "together/": [
+        ProviderDefault("together", "TOGETHER_API_KEY"),
+        # No Mirascope fallback for together
+    ],
+    "ollama/": [
+        ProviderDefault("ollama", None),  # No API key required
+    ],
+    "mlx-community/": [
+        ProviderDefault("mlx", None),  # No API key required
+    ],
 }
 
 
+def _has_api_key(default: ProviderDefault) -> bool:
+    """Check if the API key for a provider default is available.
+
+    Args:
+        default: The provider default configuration to check.
+
+    Returns:
+        True if the API key is available or not required, False otherwise.
+    """
+    if default.api_key_env_var is None:
+        return True  # Provider doesn't require API key
+    return os.environ.get(default.api_key_env_var) is not None
+
+
 @lru_cache(maxsize=256)
 def provider_singleton(
     provider_id: ProviderId, *, api_key: str | None = None, base_url: str | None = None
@@ -175,6 +224,10 @@ def get_provider_for_model(model_id: str) -> Provider:
     If no explicit registration is found, checks for auto-registration defaults
     and automatically registers the provider on first use.
 
+    When auto-registering, providers are tried in fallback order. For example,
+    if ANTHROPIC_API_KEY is not set but MIRASCOPE_API_KEY is, the Mirascope
+    Router will be used as a fallback for anthropic/ models.
+
     Args:
         model_id: The full model ID (e.g., "anthropic/claude-4-5-sonnet").
 
@@ -182,7 +235,8 @@ def get_provider_for_model(model_id: str) -> Provider:
         The provider instance registered for this model.
 
     Raises:
-        ValueError: If no provider is registered or available for this model.
+        NoRegisteredProviderError: If no provider scope matches the model_id.
+        MissingAPIKeyError: If no provider in the fallback chain has its API key set.
 
     Example:
         ```python
@@ -199,6 +253,11 @@ def get_provider_for_model(model_id: str) -> Provider:
         # Auto-registration on first use:
         provider = get_provider_for_model("openai/gpt-4")
         # Automatically loads and registers OpenAIProvider() for "openai/"
+
+        # Fallback to Mirascope Router if direct key missing:
+        # (with MIRASCOPE_API_KEY set but not ANTHROPIC_API_KEY)
+        provider = get_provider_for_model("anthropic/claude-4-5-sonnet")
+        # Returns MirascopeProvider registered for "anthropic/" scope
         ```
     """
     # Try explicit registry first (longest match wins)
@@ -209,17 +268,32 @@ def get_provider_for_model(model_id: str) -> Provider:
         best_scope = max(matching_scopes, key=len)
         return PROVIDER_REGISTRY[best_scope]
 
-    # Fall back to auto-registration
+    # Fall back to auto-registration with fallback chain
     matching_defaults = [
         scope for scope in DEFAULT_AUTO_REGISTER_SCOPES if model_id.startswith(scope)
     ]
     if matching_defaults:
         best_scope = max(matching_defaults, key=len)
-        provider_id = DEFAULT_AUTO_REGISTER_SCOPES[best_scope]
-        provider = provider_singleton(provider_id)
-        # Auto-register for future calls
-        PROVIDER_REGISTRY[best_scope] = provider
-        return provider
-
-    # No provider found
+        fallback_chain = DEFAULT_AUTO_REGISTER_SCOPES[best_scope]
+
+        # Try each provider in the fallback chain
+        for default in fallback_chain:
+            if _has_api_key(default):
+                provider = provider_singleton(default.provider_id)
+                # Register for just this scope (not all provider's default scopes)
+                PROVIDER_REGISTRY[best_scope] = provider
+                return provider
+
+        # No provider in chain has API key - raise helpful error
+        primary = fallback_chain[0]
+        has_mirascope_fallback = any(
+            d.provider_id == "mirascope" for d in fallback_chain
+        )
+        raise MissingAPIKeyError(
+            provider_id=primary.provider_id,
+            env_var=primary.api_key_env_var or "",
+            has_mirascope_fallback=has_mirascope_fallback,
+        )
+
+    # No matching scope at all
     raise NoRegisteredProviderError(model_id)

mirascope/llm/responses/__init__.py

@@ -1,16 +1,18 @@
 """The Responses module for LLM responses."""
 
 from . import _utils
+from .base_response import ResponseT
 from .base_stream_response import (
     AsyncChunkIterator,
     ChunkIterator,
     RawMessageChunk,
     RawStreamEventChunk,
     StreamResponseChunk,
+    StreamResponseT,
 )
 from .finish_reason import FinishReason, FinishReasonChunk
 from .response import AsyncContextResponse, AsyncResponse, ContextResponse, Response
-from .root_response import RootResponse
+from .root_response import AnyResponse, RootResponse
 from .stream_response import (
     AsyncContextStreamResponse,
     AsyncStreamResponse,
@@ -30,6 +32,7 @@ from .streams import (
 from .usage import Usage, UsageDeltaChunk
 
 __all__ = [
+    "AnyResponse",
     "AsyncChunkIterator",
     "AsyncContextResponse",
     "AsyncContextStreamResponse",
@@ -47,10 +50,12 @@ __all__ = [
     "RawMessageChunk",
     "RawStreamEventChunk",
     "Response",
+    "ResponseT",
     "RootResponse",
     "Stream",
     "StreamResponse",
     "StreamResponseChunk",
+    "StreamResponseT",
     "TextStream",
     "ThoughtStream",
     "ToolCallStream",

mirascope/llm/responses/_utils.py

@@ -1,20 +1,34 @@
-def extract_serialized_json(text: str) -> str:
-    """Extract the serialized JSON string from text that may contain extra content.
+"""Utilities for response classes."""
+
+import json
+from typing import cast
+
+import jiter
+from pydantic import BaseModel
+
+from ..formatting import (
+    FormattableT,
+    Partial,
+    PrimitiveWrapperModel,
+    create_wrapper_model,
+    is_primitive_type,
+)
+
+
+def _strip_json_preamble(text: str) -> str | None:
+    """Strip preamble text before JSON content.
 
     Handles cases where models output text before JSON like:
-    "Sure thing! Here's the JSON:\n{...}"
+    "Sure thing! Here's the JSON:\n{..."
 
     Or cases where the model wraps the JSON in code blocks like:
-    "```json\n{...}\n```"
+    "```json\n{..."
 
     Args:
         text: The raw text that may contain a JSON object
 
-    Raises:
-        ValueError: If no serialized json object string was found.
-
     Returns:
-        The extracted serialized JSON string
+        Text starting from the opening `{`, or None if no `{` found.
     """
     code_block_start_marker = "```json"
     code_block_start = text.find(code_block_start_marker)
@@ -25,14 +39,39 @@ def extract_serialized_json(text: str) -> str:
 
     json_start = text.find("{")
     if json_start == -1:
-        raise ValueError("Could not extract json: no opening `{`")
+        return None
+
+    return text[json_start:]
+
+
+def extract_serialized_json(text: str) -> str:
+    """Extract the serialized JSON string from text that may contain extra content.
+
+    Handles cases where models output text before JSON like:
+    "Sure thing! Here's the JSON:\n{...}"
+
+    Or cases where the model wraps the JSON in code blocks like:
+    "```json\n{...}\n```"
+
+    Args:
+        text: The raw text that may contain a JSON object
+
+    Raises:
+        json.JSONDecodeError: If no valid JSON object could be extracted.
+
+    Returns:
+        The extracted serialized JSON string
+    """
+    stripped = _strip_json_preamble(text)
+    if stripped is None:
+        raise json.JSONDecodeError("No JSON object found: missing '{'", text, 0)
 
     # Find the matching closing brace
     brace_count = 0
     in_string = False
     escaped = False
 
-    for i, char in enumerate(text[json_start:], json_start):
+    for i, char in enumerate(stripped):
         if escaped:
             escaped = False
             continue
@@ -51,6 +90,57 @@ def extract_serialized_json(text: str) -> str:
             elif char == "}":
                 brace_count -= 1
                 if brace_count == 0:
-                    return text[json_start : i + 1]
+                    return stripped[: i + 1]
+
+    raise json.JSONDecodeError("No JSON object found: missing '}'", text, len(text))
+
+
+def parse_partial_json(
+    json_text: str, formattable: type[FormattableT]
+) -> FormattableT | Partial[FormattableT] | None:
+    """Parse incomplete JSON into a Partial model for structured streaming.
+
+    Uses jiter's partial mode to handle incomplete JSON gracefully.
+    Returns None if JSON cannot be parsed yet.
+
+    Handles cases where models output text before JSON like:
+    "Sure thing! Here's the JSON:\n{..."
+
+    Args:
+        json_text: The incomplete JSON string to parse
+        formattable: The target format type (BaseModel or PrimitiveType)
+
+    Returns:
+        Parsed partial object, or None if unparsable
+
+    Example:
+        >>> from pydantic import BaseModel
+        >>> class Book(BaseModel):
+        ...     title: str
+        ...     author: str
+        >>> parse_partial_json('{"title": "The Name"', Book)
+        PartialBook(title='The Name', author=None)
+    """
+    # Strip preamble text before JSON
+    stripped = _strip_json_preamble(json_text)
+    if stripped is None:
+        return None
+
+    try:
+        parsed = jiter.from_json(stripped.encode(), partial_mode="trailing-strings")
+    except Exception:
+        return None
+
+    target_model = formattable
+    if is_primitive_type(target_model):
+        target_model = cast(BaseModel, create_wrapper_model(target_model))
+
+    try:
+        instance = cast(BaseModel, Partial[target_model]).model_validate(parsed)
+    except Exception:
+        return None
+
+    if is_primitive_type(formattable):
+        return cast(PrimitiveWrapperModel, instance).output
 
-    raise ValueError("Could not extract json: no closing `}`")
+    return cast(Partial[FormattableT], instance)

mirascope/llm/responses/base_response.py

@@ -1,7 +1,7 @@
 """Shared base of Response and AsyncResponse."""
 
 from collections.abc import Sequence
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, TypeVar
 
 from ..content import Text, Thought, ToolCall
 from ..formatting import Format, FormattableT
@@ -12,7 +12,10 @@ from .root_response import RootResponse
 from .usage import Usage
 
 if TYPE_CHECKING:
-    from ..providers import ModelId, Params, ProviderId
+    from ..models import Params
+    from ..providers import ModelId, ProviderId
+
+ResponseT = TypeVar("ResponseT", bound="BaseResponse[Any, Any]")
 
 
 class BaseResponse(RootResponse[ToolkitT, FormattableT]):