prompture 0.0.40.dev1__py3-none-any.whl → 0.0.43.dev1__py3-none-any.whl

prompture/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.0.40.dev1'
-__version_tuple__ = version_tuple = (0, 0, 40, 'dev1')
+__version__ = version = '0.0.43.dev1'
+__version_tuple__ = version_tuple = (0, 0, 43, 'dev1')
 
 __commit_id__ = commit_id = None

prompture/agent.py

@@ -188,7 +188,7 @@ class Agent(Generic[DepsType]):
             for fn in tools:
                 self._tools.register(fn)
 
-        self._state = AgentState.idle
+        self._lifecycle = AgentState.idle
         self._stop_requested = False
 
     # ------------------------------------------------------------------
@@ -206,7 +206,7 @@ class Agent(Generic[DepsType]):
     @property
     def state(self) -> AgentState:
         """Current lifecycle state of the agent."""
-        return self._state
+        return self._lifecycle
 
     def stop(self) -> None:
         """Request graceful shutdown after the current iteration."""
@@ -265,16 +265,16 @@ class Agent(Generic[DepsType]):
             prompt: The user prompt to send.
             deps: Optional dependencies injected into :class:`RunContext`.
         """
-        self._state = AgentState.running
+        self._lifecycle = AgentState.running
         self._stop_requested = False
         steps: list[AgentStep] = []
 
         try:
             result = self._execute(prompt, steps, deps)
-            self._state = AgentState.idle
+            self._lifecycle = AgentState.idle
             return result
         except Exception:
-            self._state = AgentState.errored
+            self._lifecycle = AgentState.errored
             raise
 
     # ------------------------------------------------------------------
@@ -722,7 +722,7 @@ class Agent(Generic[DepsType]):
 
     def _execute_iter(self, prompt: str, deps: Any) -> Generator[AgentStep, None, AgentResult]:
         """Generator that executes the agent loop and yields each step."""
-        self._state = AgentState.running
+        self._lifecycle = AgentState.running
         self._stop_requested = False
         steps: list[AgentStep] = []
 
@@ -730,10 +730,10 @@ class Agent(Generic[DepsType]):
             result = self._execute(prompt, steps, deps)
             # Yield each step one at a time
             yield from result.steps
-            self._state = AgentState.idle
+            self._lifecycle = AgentState.idle
             return result
         except Exception:
-            self._state = AgentState.errored
+            self._lifecycle = AgentState.errored
             raise
 
     # ------------------------------------------------------------------
@@ -757,7 +757,7 @@ class Agent(Generic[DepsType]):
 
     def _execute_stream(self, prompt: str, deps: Any) -> Generator[StreamEvent, None, AgentResult]:
         """Generator that executes the agent loop and yields stream events."""
-        self._state = AgentState.running
+        self._lifecycle = AgentState.running
         self._stop_requested = False
         steps: list[AgentStep] = []
 
@@ -853,10 +853,10 @@ class Agent(Generic[DepsType]):
                 data=result,
             )
 
-            self._state = AgentState.idle
+            self._lifecycle = AgentState.idle
             return result
         except Exception:
-            self._state = AgentState.errored
+            self._lifecycle = AgentState.errored
             raise
 
 

prompture/async_agent.py

@@ -182,7 +182,7 @@ class AsyncAgent(Generic[DepsType]):
             for fn in tools:
                 self._tools.register(fn)
 
-        self._state = AgentState.idle
+        self._lifecycle = AgentState.idle
         self._stop_requested = False
 
     # ------------------------------------------------------------------
@@ -197,7 +197,7 @@ class AsyncAgent(Generic[DepsType]):
     @property
     def state(self) -> AgentState:
         """Current lifecycle state of the agent."""
-        return self._state
+        return self._lifecycle
 
     def stop(self) -> None:
         """Request graceful shutdown after the current iteration."""
@@ -264,16 +264,16 @@ class AsyncAgent(Generic[DepsType]):
         Creates a fresh conversation, sends the prompt, handles tool calls,
         and optionally parses the final response into ``output_type``.
         """
-        self._state = AgentState.running
+        self._lifecycle = AgentState.running
         self._stop_requested = False
         steps: list[AgentStep] = []
 
         try:
             result = await self._execute(prompt, steps, deps)
-            self._state = AgentState.idle
+            self._lifecycle = AgentState.idle
             return result
         except Exception:
-            self._state = AgentState.errored
+            self._lifecycle = AgentState.errored
             raise
 
     async def iter(self, prompt: str, *, deps: Any = None) -> AsyncAgentIterator:
@@ -714,7 +714,7 @@ class AsyncAgent(Generic[DepsType]):
 
     async def _execute_iter(self, prompt: str, deps: Any) -> AsyncGenerator[AgentStep, None]:
         """Async generator that executes the agent loop and yields each step."""
-        self._state = AgentState.running
+        self._lifecycle = AgentState.running
         self._stop_requested = False
         steps: list[AgentStep] = []
 
@@ -722,11 +722,11 @@ class AsyncAgent(Generic[DepsType]):
             result = await self._execute(prompt, steps, deps)
             for step in result.steps:
                 yield step
-            self._state = AgentState.idle
+            self._lifecycle = AgentState.idle
             # Store result on the generator for retrieval
             self._last_iter_result = result
         except Exception:
-            self._state = AgentState.errored
+            self._lifecycle = AgentState.errored
             raise
 
     # ------------------------------------------------------------------
@@ -735,7 +735,7 @@ class AsyncAgent(Generic[DepsType]):
 
     async def _execute_stream(self, prompt: str, deps: Any) -> AsyncGenerator[StreamEvent, None]:
         """Async generator that executes the agent loop and yields stream events."""
-        self._state = AgentState.running
+        self._lifecycle = AgentState.running
         self._stop_requested = False
         steps: list[AgentStep] = []
 
@@ -803,10 +803,10 @@ class AsyncAgent(Generic[DepsType]):
 
             yield StreamEvent(event_type=StreamEventType.output, data=result)
 
-            self._state = AgentState.idle
+            self._lifecycle = AgentState.idle
             self._last_stream_result = result
         except Exception:
-            self._state = AgentState.errored
+            self._lifecycle = AgentState.errored
             raise
 
 

prompture/async_groups.py

@@ -70,6 +70,27 @@ class ParallelGroup:
         """Request graceful shutdown."""
         self._stop_requested = True
 
+    @property
+    def shared_state(self) -> dict[str, Any]:
+        """Return a copy of the current shared execution state."""
+        return dict(self._state)
+
+    def inject_state(self, state: dict[str, Any], *, recursive: bool = False) -> None:
+        """Merge external key-value pairs into this group's shared state.
+
+        Existing keys are NOT overwritten (uses setdefault semantics).
+
+        Args:
+            state: Key-value pairs to inject.
+            recursive: If True, also inject into nested sub-groups.
+        """
+        for k, v in state.items():
+            self._state.setdefault(k, v)
+        if recursive:
+            for agent, _ in self._agents:
+                if hasattr(agent, "inject_state"):
+                    agent.inject_state(state, recursive=True)
+
     async def run_async(self, prompt: str = "") -> GroupResult:
         """Execute all agents concurrently."""
         self._stop_requested = False
@@ -213,6 +234,27 @@ class AsyncSequentialGroup:
     def stop(self) -> None:
         self._stop_requested = True
 
+    @property
+    def shared_state(self) -> dict[str, Any]:
+        """Return a copy of the current shared execution state."""
+        return dict(self._state)
+
+    def inject_state(self, state: dict[str, Any], *, recursive: bool = False) -> None:
+        """Merge external key-value pairs into this group's shared state.
+
+        Existing keys are NOT overwritten (uses setdefault semantics).
+
+        Args:
+            state: Key-value pairs to inject.
+            recursive: If True, also inject into nested sub-groups.
+        """
+        for k, v in state.items():
+            self._state.setdefault(k, v)
+        if recursive:
+            for agent, _ in self._agents:
+                if hasattr(agent, "inject_state"):
+                    agent.inject_state(state, recursive=True)
+
     async def run(self, prompt: str = "") -> GroupResult:
         """Execute all agents in sequence (async)."""
         self._stop_requested = False
@@ -351,6 +393,27 @@ class AsyncLoopGroup:
     def stop(self) -> None:
         self._stop_requested = True
 
+    @property
+    def shared_state(self) -> dict[str, Any]:
+        """Return a copy of the current shared execution state."""
+        return dict(self._state)
+
+    def inject_state(self, state: dict[str, Any], *, recursive: bool = False) -> None:
+        """Merge external key-value pairs into this group's shared state.
+
+        Existing keys are NOT overwritten (uses setdefault semantics).
+
+        Args:
+            state: Key-value pairs to inject.
+            recursive: If True, also inject into nested sub-groups.
+        """
+        for k, v in state.items():
+            self._state.setdefault(k, v)
+        if recursive:
+            for agent, _ in self._agents:
+                if hasattr(agent, "inject_state"):
+                    agent.inject_state(state, recursive=True)
+
     async def run(self, prompt: str = "") -> GroupResult:
         """Execute the loop (async)."""
         self._stop_requested = False

prompture/cost_mixin.py

@@ -2,9 +2,34 @@
 
 from __future__ import annotations
 
+import copy
 from typing import Any
 
 
+def prepare_strict_schema(schema: dict[str, Any]) -> dict[str, Any]:
+    """Prepare a JSON schema for OpenAI strict structured-output mode.
+
+    OpenAI's ``strict: true`` requires every object to have
+    ``"additionalProperties": false`` and a ``"required"`` array listing
+    all property keys.  This function recursively patches a schema copy
+    so callers don't need to worry about these constraints.
+    """
+    schema = copy.deepcopy(schema)
+    _patch_strict(schema)
+    return schema
+
+
+def _patch_strict(node: dict[str, Any]) -> None:
+    """Recursively add strict-mode constraints to an object schema node."""
+    if node.get("type") == "object" and "properties" in node:
+        node.setdefault("additionalProperties", False)
+        node.setdefault("required", list(node["properties"].keys()))
+        for prop in node["properties"].values():
+            _patch_strict(prop)
+    elif node.get("type") == "array" and isinstance(node.get("items"), dict):
+        _patch_strict(node["items"])
+
+
 class CostMixin:
     """Mixin that provides ``_calculate_cost`` to sync and async drivers.
 

prompture/discovery.py

@@ -10,6 +10,7 @@ from typing import Any, overload
 import requests
 
 from .drivers import (
+    AirLLMDriver,
     AzureDriver,
     ClaudeDriver,
     GoogleDriver,
@@ -17,9 +18,12 @@ from .drivers import (
     GroqDriver,
     LMStudioDriver,
     LocalHTTPDriver,
+    ModelScopeDriver,
+    MoonshotDriver,
     OllamaDriver,
     OpenAIDriver,
     OpenRouterDriver,
+    ZaiDriver,
 )
 from .settings import settings
 
@@ -71,6 +75,10 @@ def get_available_models(
         "ollama": OllamaDriver,
         "lmstudio": LMStudioDriver,
         "local_http": LocalHTTPDriver,
+        "moonshot": MoonshotDriver,
+        "zai": ZaiDriver,
+        "modelscope": ModelScopeDriver,
+        "airllm": AirLLMDriver,
     }
 
     for provider, driver_cls in provider_classes.items():
@@ -102,6 +110,18 @@ def get_available_models(
             elif provider == "grok":
                 if settings.grok_api_key or os.getenv("GROK_API_KEY"):
                     is_configured = True
+            elif provider == "moonshot":
+                if settings.moonshot_api_key or os.getenv("MOONSHOT_API_KEY"):
+                    is_configured = True
+            elif provider == "zai":
+                if settings.zhipu_api_key or os.getenv("ZHIPU_API_KEY"):
+                    is_configured = True
+            elif provider == "modelscope":
+                if settings.modelscope_api_key or os.getenv("MODELSCOPE_API_KEY"):
+                    is_configured = True
+            elif provider == "airllm":
+                # AirLLM runs locally, always considered configured
+                is_configured = True
             elif (
                 provider == "ollama"
                 or provider == "lmstudio"

prompture/drivers/__init__.py

@@ -37,10 +37,13 @@ from .async_groq_driver import AsyncGroqDriver
 from .async_hugging_driver import AsyncHuggingFaceDriver
 from .async_lmstudio_driver import AsyncLMStudioDriver
 from .async_local_http_driver import AsyncLocalHTTPDriver
+from .async_modelscope_driver import AsyncModelScopeDriver
+from .async_moonshot_driver import AsyncMoonshotDriver
 from .async_ollama_driver import AsyncOllamaDriver
 from .async_openai_driver import AsyncOpenAIDriver
 from .async_openrouter_driver import AsyncOpenRouterDriver
 from .async_registry import ASYNC_DRIVER_REGISTRY, get_async_driver, get_async_driver_for_model
+from .async_zai_driver import AsyncZaiDriver
 from .azure_driver import AzureDriver
 from .claude_driver import ClaudeDriver
 from .google_driver import GoogleDriver
@@ -48,6 +51,8 @@ from .grok_driver import GrokDriver
 from .groq_driver import GroqDriver
 from .lmstudio_driver import LMStudioDriver
 from .local_http_driver import LocalHTTPDriver
+from .modelscope_driver import ModelScopeDriver
+from .moonshot_driver import MoonshotDriver
 from .ollama_driver import OllamaDriver
 from .openai_driver import OpenAIDriver
 from .openrouter_driver import OpenRouterDriver
@@ -65,6 +70,7 @@ from .registry import (
     unregister_async_driver,
     unregister_driver,
 )
+from .zai_driver import ZaiDriver
 
 # Register built-in sync drivers
 register_driver(
@@ -123,6 +129,33 @@ register_driver(
     lambda model=None: GrokDriver(api_key=settings.grok_api_key, model=model or settings.grok_model),
     overwrite=True,
 )
+register_driver(
+    "moonshot",
+    lambda model=None: MoonshotDriver(
+        api_key=settings.moonshot_api_key,
+        model=model or settings.moonshot_model,
+        endpoint=settings.moonshot_endpoint,
+    ),
+    overwrite=True,
+)
+register_driver(
+    "modelscope",
+    lambda model=None: ModelScopeDriver(
+        api_key=settings.modelscope_api_key,
+        model=model or settings.modelscope_model,
+        endpoint=settings.modelscope_endpoint,
+    ),
+    overwrite=True,
+)
+register_driver(
+    "zai",
+    lambda model=None: ZaiDriver(
+        api_key=settings.zhipu_api_key,
+        model=model or settings.zhipu_model,
+        endpoint=settings.zhipu_endpoint,
+    ),
+    overwrite=True,
+)
 register_driver(
     "airllm",
     lambda model=None: AirLLMDriver(
@@ -197,9 +230,12 @@ __all__ = [
     "AsyncHuggingFaceDriver",
     "AsyncLMStudioDriver",
     "AsyncLocalHTTPDriver",
+    "AsyncModelScopeDriver",
+    "AsyncMoonshotDriver",
     "AsyncOllamaDriver",
     "AsyncOpenAIDriver",
     "AsyncOpenRouterDriver",
+    "AsyncZaiDriver",
     "AzureDriver",
     "ClaudeDriver",
     "GoogleDriver",
@@ -207,9 +243,12 @@ __all__ = [
     "GroqDriver",
     "LMStudioDriver",
     "LocalHTTPDriver",
+    "ModelScopeDriver",
+    "MoonshotDriver",
     "OllamaDriver",
     "OpenAIDriver",
     "OpenRouterDriver",
+    "ZaiDriver",
     "get_async_driver",
     "get_async_driver_for_model",
     # Factory functions

prompture/drivers/async_azure_driver.py

@@ -11,7 +11,7 @@ except Exception:
     AsyncAzureOpenAI = None
 
 from ..async_driver import AsyncDriver
-from ..cost_mixin import CostMixin
+from ..cost_mixin import CostMixin, prepare_strict_schema
 from .azure_driver import AzureDriver
 
 
@@ -89,12 +89,13 @@ class AsyncAzureDriver(CostMixin, AsyncDriver):
         if options.get("json_mode"):
             json_schema = options.get("json_schema")
             if json_schema:
+                schema_copy = prepare_strict_schema(json_schema)
                 kwargs["response_format"] = {
                     "type": "json_schema",
                     "json_schema": {
                         "name": "extraction",
                         "strict": True,
-                        "schema": json_schema,
+                        "schema": schema_copy,
                     },
                 }
             else: