agent-runtime-core 0.9.0__tar.gz → 0.9.1__tar.gz

agent_runtime_core-0.9.1/LICENSE

@@ -0,0 +1,83 @@
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Parameters
+
+Licensor:             Chris Barry
+Licensed Work:        agent-runtime-core
+                      The Licensed Work is (c) 2025 Chris Barry
+Additional Use Grant: You may use the Licensed Work for non-production purposes,
+                      including development, testing, and evaluation. Production
+                      use requires a commercial license from the Licensor.
+Change Date:          2029-01-24
+Change License:       MIT
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production
+use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph above
+terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive the Licensed Work in original or
+modified form from a third party, the terms and conditions set forth in this
+License apply to your use of that work.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License's text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License's text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided by Licensor:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.
+

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agent-runtime-core
-Version: 0.9.0
+Version: 0.9.1
 Summary: Framework-agnostic Python library for executing AI agents with consistent patterns
 Project-URL: Homepage, https://github.com/makemore/agent-runtime-core
 Project-URL: Repository, https://github.com/makemore/agent-runtime-core

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/agentic_loop.py

@@ -154,7 +154,7 @@ async def run_agentic_loop(
     ctx: RunContext,
     *,
     model: Optional[str] = None,
-    max_iterations: int = 15,
+    max_iterations: Optional[int] = None,
     emit_events: bool = True,
     ensure_final_response: bool = False,
     **llm_kwargs,
@@ -175,7 +175,8 @@ async def run_agentic_loop(
         execute_tool: Async function that executes a tool: (name, args) -> result
         ctx: Run context for emitting events
         model: Model to use (passed to LLM client)
-        max_iterations: Maximum loop iterations to prevent infinite loops
+        max_iterations: Maximum loop iterations to prevent infinite loops.
+            If None, uses the value from config (default: 50).
         emit_events: Whether to emit TOOL_CALL and TOOL_RESULT events
         ensure_final_response: If True, ensures a summary is generated when tools
             were used but the final response is empty or very short. This is useful
@@ -208,14 +209,18 @@ async def run_agentic_loop(
     max_consecutive_errors = 3  # Bail out if tool keeps failing
 
     # Initialize usage tracking (enabled in debug mode)
-    debug_mode = get_config().debug
+    config = get_config()
+    debug_mode = config.debug
     usage_stats = UsageStats() if debug_mode else None
     effective_model = model or "unknown"
 
-    while iteration < max_iterations:
+    # Use config default if max_iterations not specified
+    effective_max_iterations = max_iterations if max_iterations is not None else config.max_iterations
+
+    while iteration < effective_max_iterations:
         iteration += 1
-        print(f"[agentic-loop] Iteration {iteration}/{max_iterations}, messages={len(messages)}", flush=True)
-        logger.debug(f"Agentic loop iteration {iteration}/{max_iterations}")
+        print(f"[agentic-loop] Iteration {iteration}/{effective_max_iterations}, messages={len(messages)}", flush=True)
+        logger.debug(f"Agentic loop iteration {iteration}/{effective_max_iterations}")
 
         # Call LLM
         if tools:

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/config.py

@@ -91,6 +91,9 @@ class RuntimeConfig:
     # Debug mode - enables verbose logging, cost tracking, etc.
     debug: bool = False
 
+    # Agentic loop settings
+    max_iterations: int = 50  # Maximum iterations for tool-calling loops
+
     def get_openai_api_key(self) -> Optional[str]:
         """Get OpenAI API key from config or environment."""
         return self.openai_api_key or os.environ.get("OPENAI_API_KEY")
@@ -202,6 +205,7 @@ def _apply_env_vars(config: RuntimeConfig) -> None:
         "AGENT_RUNTIME_RETRY_BACKOFF_BASE": "retry_backoff_base",
         "AGENT_RUNTIME_RETRY_BACKOFF_MAX": "retry_backoff_max",
         "AGENT_RUNTIME_MAX_HISTORY_MESSAGES": "max_history_messages",
+        "AGENT_RUNTIME_MAX_ITERATIONS": "max_iterations",
     }
 
     bool_fields = {

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/interfaces.py

@@ -323,13 +323,21 @@ class ToolRegistry:
         """
         return self.to_openai_format()
 
-    async def execute(self, name: str, arguments: dict) -> Any:
+    async def execute(
+        self,
+        name: str,
+        arguments: dict,
+        ctx: Optional["RunContext"] = None,
+        **kwargs
+    ) -> Any:
         """
         Execute a tool by name.
 
         Args:
             name: Tool name
             arguments: Tool arguments
+            ctx: Optional RunContext, passed to handlers with requires_context=True
+            **kwargs: Additional arguments to pass to the handler
 
         Returns:
             Tool result
@@ -340,7 +348,15 @@ class ToolRegistry:
         tool = self._tools.get(name)
         if not tool:
             raise KeyError(f"Tool not found: {name}")
-        return await tool.handler(**arguments)
+
+        # Check if the tool requires context
+        requires_context = tool.metadata.get('requires_context', False) if tool.metadata else False
+
+        if requires_context and ctx is not None:
+            # Pass ctx to the handler for tools that need it (e.g., sub-agent tools)
+            return await tool.handler(**arguments, ctx=ctx, **kwargs)
+        else:
+            return await tool.handler(**arguments, **kwargs)
 
     async def execute_with_events(
         self,
@@ -350,19 +366,19 @@ class ToolRegistry:
     ) -> Any:
         """
         Execute a tool and automatically emit events.
-        
+
         This is a convenience method that wraps execute() and handles
         event emission automatically. Use this in your agent loop to
         reduce boilerplate.
-        
+
         Args:
             tool_call: Tool call object with name, arguments, and id
             ctx: Run context for emitting events
             **kwargs: Additional arguments to pass to the tool
-        
+
         Returns:
             Tool result
-        
+
         Example:
             for tool_call in response.tool_calls:
                 result = await tools.execute_with_events(tool_call, ctx)
@@ -373,17 +389,17 @@ class ToolRegistry:
             "tool_args": tool_call.arguments,
             "tool_call_id": tool_call.id,
         })
-        
-        # Execute the tool
-        result = await self.execute(tool_call.name, tool_call.arguments, **kwargs)
-        
+
+        # Execute the tool, passing ctx for tools that require it
+        result = await self.execute(tool_call.name, tool_call.arguments, ctx=ctx, **kwargs)
+
         # Emit tool result event
         await ctx.emit(EventType.TOOL_RESULT, {
             "tool_name": tool_call.name,
             "tool_call_id": tool_call.id,
             "result": result,
         })
-        
+
         return result
 
 
@@ -501,6 +517,7 @@ class LLMResponse:
     model: str = ""
     finish_reason: str = ""
     raw_response: Optional[Any] = None
+    thinking: Optional[str] = None  # Extended thinking content (Anthropic)
 
     @property
     def tool_calls(self) -> Optional[list["LLMToolCall"]]:
@@ -528,6 +545,7 @@ class LLMStreamChunk:
     tool_calls: Optional[list] = None
     finish_reason: Optional[str] = None
     usage: Optional[dict] = None
+    thinking: Optional[str] = None  # Extended thinking content (Anthropic)
 
 
 class TraceSink(ABC):

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/llm/anthropic.py

@@ -176,9 +176,27 @@ class AnthropicClient(LLMClient):
         tools: Optional[list[dict]] = None,
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
+        thinking: bool = False,
+        thinking_budget: Optional[int] = None,
         **kwargs,
     ) -> LLMResponse:
-        """Generate a completion from Anthropic."""
+        """
+        Generate a completion from Anthropic.
+
+        Args:
+            messages: List of messages in framework-neutral format
+            model: Model ID to use (defaults to self.default_model)
+            stream: Whether to stream the response (not used here, use stream() method)
+            tools: List of tools in OpenAI format
+            temperature: Sampling temperature (0.0 to 1.0)
+            max_tokens: Maximum tokens to generate
+            thinking: Enable extended thinking mode for deeper reasoning
+            thinking_budget: Max tokens for thinking (default: 10000, max: 128000)
+            **kwargs: Additional parameters passed to the API
+
+        Returns:
+            LLMResponse with the generated message
+        """
         model = model or self.default_model
 
         # Validate and repair message history before processing
@@ -206,15 +224,28 @@ class AnthropicClient(LLMClient):
             request_kwargs["system"] = system_message
         if tools:
             request_kwargs["tools"] = self._convert_tools(tools)
-        if temperature is not None:
+
+        # Handle extended thinking mode
+        if thinking:
+            # Extended thinking requires specific configuration
+            # Temperature must be 1.0 when using thinking
+            request_kwargs["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": thinking_budget or 10000,
+            }
+            # Temperature must be exactly 1.0 for extended thinking
+            request_kwargs["temperature"] = 1.0
+        elif temperature is not None:
             request_kwargs["temperature"] = temperature
 
         request_kwargs.update(kwargs)
 
         response = await self._client.messages.create(**request_kwargs)
 
+        message, thinking_content = self._convert_response(response)
+
         return LLMResponse(
-            message=self._convert_response(response),
+            message=message,
             usage={
                 "prompt_tokens": response.usage.input_tokens,
                 "completion_tokens": response.usage.output_tokens,
@@ -223,6 +254,7 @@ class AnthropicClient(LLMClient):
             model=response.model,
             finish_reason=response.stop_reason or "",
             raw_response=response,
+            thinking=thinking_content,
         )
 
     async def stream(
@@ -231,9 +263,26 @@ class AnthropicClient(LLMClient):
         *,
         model: Optional[str] = None,
         tools: Optional[list[dict]] = None,
+        thinking: bool = False,
+        thinking_budget: Optional[int] = None,
+        temperature: Optional[float] = None,
         **kwargs,
     ) -> AsyncIterator[LLMStreamChunk]:
-        """Stream a completion from Anthropic."""
+        """
+        Stream a completion from Anthropic.
+
+        Args:
+            messages: List of messages in framework-neutral format
+            model: Model ID to use
+            tools: List of tools in OpenAI format
+            thinking: Enable extended thinking mode
+            thinking_budget: Max tokens for thinking (default: 10000)
+            temperature: Sampling temperature (ignored if thinking=True)
+            **kwargs: Additional parameters
+
+        Yields:
+            LLMStreamChunk with delta content and thinking content
+        """
         model = model or self.default_model
 
         # Validate and repair message history before processing
@@ -262,6 +311,16 @@ class AnthropicClient(LLMClient):
         if tools:
             request_kwargs["tools"] = self._convert_tools(tools)
 
+        # Handle extended thinking mode
+        if thinking:
+            request_kwargs["thinking"] = {
+                "type": "enabled",
+                "budget_tokens": thinking_budget or 10000,
+            }
+            request_kwargs["temperature"] = 1.0
+        elif temperature is not None:
+            request_kwargs["temperature"] = temperature
+
         request_kwargs.update(kwargs)
 
         async with self._client.messages.stream(**request_kwargs) as stream:
@@ -269,6 +328,9 @@ class AnthropicClient(LLMClient):
                 if event.type == "content_block_delta":
                     if hasattr(event.delta, "text"):
                         yield LLMStreamChunk(delta=event.delta.text)
+                    elif hasattr(event.delta, "thinking"):
+                        # Extended thinking content
+                        yield LLMStreamChunk(delta="", thinking=event.delta.thinking)
                 elif event.type == "message_stop":
                     yield LLMStreamChunk(finish_reason="stop")
 
@@ -410,14 +472,23 @@ class AnthropicClient(LLMClient):
                 })
         return result
 
-    def _convert_response(self, response) -> Message:
-        """Convert Anthropic response to our format."""
+    def _convert_response(self, response) -> tuple[Message, Optional[str]]:
+        """
+        Convert Anthropic response to our format.
+
+        Returns:
+            Tuple of (message, thinking_content)
+        """
         content = ""
         tool_calls = []
+        thinking_content = None
 
         for block in response.content:
             if block.type == "text":
                 content += block.text
+            elif block.type == "thinking":
+                # Extended thinking block
+                thinking_content = block.thinking
             elif block.type == "tool_use":
                 # Convert input to JSON string (not Python str() which gives wrong format)
                 arguments = json.dumps(block.input) if isinstance(block.input, dict) else str(block.input)
@@ -438,4 +509,4 @@ class AnthropicClient(LLMClient):
         if tool_calls:
             result["tool_calls"] = tool_calls
 
-        return result
+        return result, thinking_content

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/llm/models_config.py

@@ -22,19 +22,48 @@ class ModelInfo:
     supports_tools: bool = True
     supports_vision: bool = False
     supports_streaming: bool = True
+    supports_thinking: bool = False  # Extended thinking (Anthropic) or reasoning (OpenAI)
     description: str = ""
 
 
 # Registry of supported models
 SUPPORTED_MODELS: dict[str, ModelInfo] = {
-    # OpenAI Models
+    # OpenAI Models - GPT-5 (latest)
+    "gpt-5": ModelInfo(
+        id="gpt-5",
+        name="GPT-5",
+        provider="openai",
+        context_window=256000,
+        supports_vision=True,
+        supports_thinking=True,
+        description="Most capable OpenAI model with reasoning",
+    ),
+    "gpt-5-mini": ModelInfo(
+        id="gpt-5-mini",
+        name="GPT-5 Mini",
+        provider="openai",
+        context_window=256000,
+        supports_vision=True,
+        supports_thinking=True,
+        description="Fast GPT-5 variant with reasoning",
+    ),
+    "gpt-5-turbo": ModelInfo(
+        id="gpt-5-turbo",
+        name="GPT-5 Turbo",
+        provider="openai",
+        context_window=256000,
+        supports_vision=True,
+        supports_thinking=True,
+        description="Balanced GPT-5 variant for production",
+    ),
+    # OpenAI Models - GPT-4o
     "gpt-4o": ModelInfo(
         id="gpt-4o",
         name="GPT-4o",
         provider="openai",
         context_window=128000,
         supports_vision=True,
-        description="Most capable OpenAI model, multimodal",
+        description="Most capable GPT-4 model, multimodal",
     ),
     "gpt-4o-mini": ModelInfo(
         id="gpt-4o-mini",
@@ -52,12 +81,14 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         supports_vision=True,
         description="Previous generation flagship",
     ),
+    # OpenAI Models - o-series (reasoning)
     "o1": ModelInfo(
         id="o1",
         name="o1",
         provider="openai",
         context_window=200000,
         supports_tools=False,
+        supports_thinking=True,
         description="Advanced reasoning model",
     ),
     "o1-mini": ModelInfo(
@@ -66,6 +97,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="openai",
         context_window=128000,
         supports_tools=False,
+        supports_thinking=True,
         description="Fast reasoning model",
     ),
     "o3-mini": ModelInfo(
@@ -74,6 +106,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="openai",
         context_window=200000,
         supports_tools=True,
+        supports_thinking=True,
         description="Latest reasoning model with tool use",
     ),
     
@@ -84,6 +117,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Best balance of speed and capability for agents and coding",
     ),
     "claude-opus-4-5-20251101": ModelInfo(
@@ -92,6 +126,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Premium model - maximum intelligence with practical performance",
     ),
     "claude-haiku-4-5-20251001": ModelInfo(
@@ -100,6 +135,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Fastest model with near-frontier intelligence",
     ),
     # Anthropic Models - Claude 4 (previous generation)
@@ -109,6 +145,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Previous generation Sonnet",
     ),
     "claude-opus-4-20250514": ModelInfo(
@@ -117,6 +154,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Previous generation Opus",
     ),
     # Anthropic Models - Claude 3.5 (legacy)
@@ -126,6 +164,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Legacy model, still excellent",
     ),
     "claude-3-5-haiku-20241022": ModelInfo(
@@ -134,6 +173,7 @@ SUPPORTED_MODELS: dict[str, ModelInfo] = {
         provider="anthropic",
         context_window=200000,
         supports_vision=True,
+        supports_thinking=True,
         description="Legacy fast model",
     ),
 }
@@ -150,19 +190,20 @@ def get_model_info(model_id: str) -> Optional[ModelInfo]:
 def get_provider_for_model(model_id: str) -> Optional[str]:
     """
     Detect the provider for a model ID.
-    
+
     Returns "openai", "anthropic", or None if unknown.
     """
     # Check registry first
     if model_id in SUPPORTED_MODELS:
         return SUPPORTED_MODELS[model_id].provider
-    
+
     # Fallback heuristics for unlisted models
-    if model_id.startswith("gpt-") or model_id.startswith("o1") or model_id.startswith("o3"):
+    if (model_id.startswith("gpt-") or model_id.startswith("o1") or
+        model_id.startswith("o3") or model_id.startswith("gpt5")):
         return "openai"
     if model_id.startswith("claude"):
         return "anthropic"
-    
+
     return None
 
 
@@ -174,6 +215,9 @@ def list_models_for_ui() -> list[dict]:
             "name": m.name,
             "provider": m.provider,
             "description": m.description,
+            "supports_thinking": m.supports_thinking,
+            "supports_tools": m.supports_tools,
+            "supports_vision": m.supports_vision,
         }
         for m in SUPPORTED_MODELS.values()
     ]

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/llm/openai.py

@@ -104,9 +104,27 @@ class OpenAIClient(LLMClient):
         tools: Optional[list[dict]] = None,
         temperature: Optional[float] = None,
         max_tokens: Optional[int] = None,
+        thinking: bool = False,
+        reasoning_effort: Optional[str] = None,
         **kwargs,
     ) -> LLMResponse:
-        """Generate a completion from OpenAI."""
+        """
+        Generate a completion from OpenAI.
+
+        Args:
+            messages: List of messages in framework-neutral format
+            model: Model ID to use (defaults to self.default_model)
+            stream: Whether to stream (not used here, use stream() method)
+            tools: List of tools in OpenAI format
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens to generate
+            thinking: Enable reasoning mode for o-series and GPT-5 models
+            reasoning_effort: Reasoning effort level: "low", "medium", or "high"
+            **kwargs: Additional parameters passed to the API
+
+        Returns:
+            LLMResponse with the generated message
+        """
         model = model or self.default_model
 
         request_kwargs = {
@@ -121,6 +139,15 @@ class OpenAIClient(LLMClient):
         if max_tokens is not None:
             request_kwargs["max_tokens"] = max_tokens
 
+        # Handle reasoning mode for o-series and GPT-5 models
+        if thinking or reasoning_effort:
+            # reasoning_effort controls how much reasoning the model does
+            # Valid values: "low", "medium", "high"
+            effort = reasoning_effort or "medium"
+            if effort not in ("low", "medium", "high"):
+                effort = "medium"
+            request_kwargs["reasoning_effort"] = effort
+
         request_kwargs.update(kwargs)
 
         response = await self._client.chat.completions.create(**request_kwargs)
@@ -146,9 +173,24 @@ class OpenAIClient(LLMClient):
         *,
         model: Optional[str] = None,
         tools: Optional[list[dict]] = None,
+        thinking: bool = False,
+        reasoning_effort: Optional[str] = None,
         **kwargs,
     ) -> AsyncIterator[LLMStreamChunk]:
-        """Stream a completion from OpenAI."""
+        """
+        Stream a completion from OpenAI.
+
+        Args:
+            messages: List of messages
+            model: Model ID to use
+            tools: List of tools in OpenAI format
+            thinking: Enable reasoning mode for o-series and GPT-5 models
+            reasoning_effort: Reasoning effort level: "low", "medium", or "high"
+            **kwargs: Additional parameters
+
+        Yields:
+            LLMStreamChunk with delta content
+        """
         model = model or self.default_model
 
         request_kwargs = {
@@ -160,6 +202,13 @@ class OpenAIClient(LLMClient):
         if tools:
             request_kwargs["tools"] = tools
 
+        # Handle reasoning mode for o-series and GPT-5 models
+        if thinking or reasoning_effort:
+            effort = reasoning_effort or "medium"
+            if effort not in ("low", "medium", "high"):
+                effort = "medium"
+            request_kwargs["reasoning_effort"] = effort
+
         request_kwargs.update(kwargs)
 
         async with await self._client.chat.completions.create(**request_kwargs) as stream:

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/multi_agent.py

@@ -1230,7 +1230,17 @@ class SubAgentContext:
         return ToolRegistry()
     
     async def emit(self, event_type: EventType | str, payload: dict) -> None:
-        """Emit events through parent context with sub-agent tagging."""
+        """Emit events through parent context with sub-agent tagging.
+
+        Note: ASSISTANT_MESSAGE events are suppressed for sub-agents because
+        the parent agent will relay the response. This prevents duplicate
+        messages in the UI.
+        """
+        # Suppress ASSISTANT_MESSAGE events from sub-agents to prevent duplicates
+        # The parent agent will relay the sub-agent's response
+        if event_type == EventType.ASSISTANT_MESSAGE or event_type == "assistant.message":
+            return
+
         # Tag the event as coming from a sub-agent
         tagged_payload = dict(payload)
         tagged_payload["sub_agent_run_id"] = str(self._run_id)

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/agent_runtime_core/tool_calling_agent.py

@@ -75,8 +75,10 @@ class ToolCallingAgent(AgentRuntime):
         Maximum number of tool-calling iterations.
 
         Override to change the default limit.
+        Default uses the value from config (default: 50).
         """
-        return 15
+        from agent_runtime_core.config import get_config
+        return get_config().max_iterations
 
     @property
     def model(self) -> Optional[str]:

{agent_runtime_core-0.9.0 → agent_runtime_core-0.9.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agent-runtime-core"
-version = "0.9.0"
+version = "0.9.1"
 description = "Framework-agnostic Python library for executing AI agents with consistent patterns"
 readme = "README.md"
 license = "MIT"
@@ -103,11 +103,11 @@ testpaths = ["tests"]
 
 [tool.ruff]
 line-length = 100
-target-version = "py311"
+target-version = "0.9.1"
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "N", "W", "UP"]
 
 [tool.mypy]
-python_version = "3.11"
+python_version = "0.9.1"
 strict = true

agent_runtime_core-0.9.0/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Chris Barry
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.