aisolate-agent 0.3.2__tar.gz → 0.3.4__tar.gz

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aisolate-agent
-Version: 0.3.2
+Version: 0.3.4
 Summary: AI Agent with intelligent planning and reasoning
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -30,7 +30,7 @@ AI Agent with intelligent planning and reasoning
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_agent-0.3.2-py3-none-any.whl
+pip install path/to/aisolate_agent-0.3.4-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/README.md

@@ -5,7 +5,7 @@ AI Agent with intelligent planning and reasoning
 ## Local Installation
 
 ```bash
-pip install path/to/aisolate_agent-0.3.2-py3-none-any.whl
+pip install path/to/aisolate_agent-0.3.4-py3-none-any.whl
 ```
 
 ## Usage

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aisolate-agent"
-version = "0.3.2"
+version = "0.3.4"
 description = "AI Agent with intelligent planning and reasoning"
 readme = "README.md"
 requires-python = ">=3.10"

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/agent.py

@@ -1,6 +1,7 @@
 """Main Agent class - public API for the three-tier tool architecture."""
 
-from typing import Optional, Dict, Any, List, Iterable, TYPE_CHECKING
+from types import MappingProxyType
+from typing import Optional, Dict, Any, List, Iterable, Mapping, TYPE_CHECKING
 import asyncio
 import base64
 import contextlib
@@ -11,6 +12,11 @@ from datetime import datetime, timezone
 import aiohttp
 
 from .config.agent_settings import AgentSettings
+from .config.state_llm import (
+    StateLLMOverride,
+    resolve_effective_strategy,
+    validate_state_llm_overrides,
+)
 from .core.context import AgentContext
 from .core.graph import AgentGraph
 from .core.protocols import LLMStrategy, MemoryStrategy
@@ -136,7 +142,7 @@ class Agent:
         actions: Optional[List[Any]] = None,
         checkpoint_storage: Optional[Any] = None,
         graph: Optional[AgentGraph] = None,
-        state_model_overrides: Optional[Dict[str, str]] = None,
+        state_llm_overrides: Optional[Mapping[str, StateLLMOverride]] = None,
         file_resolver: Optional[Any] = None,
         status_llm: Optional[LLMStrategy] = None,
         status_enter_labels: Optional[Dict[str, str]] = None,
@@ -163,9 +169,11 @@ class Agent:
                 ``settings.enable_clarification``. Review is a fact of the
                 graph — an agent reviews its answers iff the graph has a
                 ``critic`` node.
-            state_model_overrides: Map of graph node name → model name.
-                Before each turn, the agent swaps ``context.llm`` to a
-                strategy configured for the overridden model.
+            state_llm_overrides: Map of graph node name → ``StateLLMOverride``
+                (model, full strategy, and/or reasoning effort). Validated at
+                construction against every graph this agent can execute;
+                before each turn, ``apply_state_llm_override`` installs the
+                node's effective strategy and effort.
             file_resolver: Optional FileResolver for resolving file URLs
                 to bytes (used by the critic for image content).
             status_enter_labels: node→text mapping for the deterministic
@@ -190,7 +198,19 @@ class Agent:
         self.graph = graph or build_workflow(
             clarification=self.settings.enable_clarification
         )
-        self.state_model_overrides = state_model_overrides or {}
+        # Per-node LLM overrides: validated here against every graph this
+        # agent can execute — its own, plus the lean sub graph that
+        # SubAgentTool forces onto delegates — then resolved once, so runtime
+        # reuses exactly the strategy objects that were validated.
+        _overrides = dict(state_llm_overrides or {})
+        validate_state_llm_overrides(
+            llm_strategy, _overrides, [self.graph, build_workflow(role="sub")]
+        )
+        self.state_llm_overrides = MappingProxyType(_overrides)
+        self._effective_llm = {
+            node: resolve_effective_strategy(llm_strategy, override)
+            for node, override in _overrides.items()
+        }
         self.file_resolver = file_resolver
         # Optional cheap side model that turns each turn into a one-line
         # user-facing status update. None disables the feature entirely.
@@ -277,6 +297,22 @@ class Agent:
         # per Agent instantiation.
         _validate_managed_agents_acyclic(self)
 
+    def apply_state_llm_override(self, context: "AgentContext") -> None:
+        """Install the current node's effective LLM configuration.
+
+        Called immediately before every paid turn — by ``run_streaming`` and
+        by ``SubAgentTool._execute_subagent`` — AFTER the node's ``on_enter``
+        installed its default hints, so an explicit override wins. A node
+        without an override runs the base strategy; a configured key absent
+        from the executing graph is skipped (valid on the agent's other
+        graph shape).
+        """
+        node = context.current_node
+        context.llm = self._effective_llm.get(node, self.llm_strategy)
+        override = self.state_llm_overrides.get(node)
+        if override is not None and override.reasoning_effort is not None:
+            context.set_state_hint("reasoning_effort", override.reasoning_effort)
+
     async def run(self, task: str) -> "FinalAnswerResult":
         """Run the agent on a single task and return the final answer.
 
@@ -1739,17 +1775,20 @@ class Agent:
                     )
                     turn_span.set_attribute("agent.task", context.task)
 
-                    # Swap LLM strategy if the current node has a model override.
-                    # Overrides can be a model name (str) or a full strategy object.
-                    override = self.state_model_overrides.get(context.current_node)
-                    if override is not None:
-                        if isinstance(override, str):
-                            context.llm = self.llm_strategy.with_model(override)
-                        else:
-                            # Full strategy object (e.g. with_model(...).with_templates(...))
-                            context.llm = override
-                    else:
-                        context.llm = self.llm_strategy
+                    # Install the node's effective LLM configuration. Sits
+                    # before the retry loop so transient retries of this turn
+                    # keep one configuration; the next iteration re-resolves
+                    # because the turn may have routed to a different node.
+                    self.apply_state_llm_override(context)
+                    turn_span.set_attribute(
+                        "agent.llm.model",
+                        getattr(context.llm, "model", None) or "unknown",
+                    )
+                    _applied_effort = context.llm.applied_reasoning_effort(context)
+                    if _applied_effort is not None:
+                        turn_span.set_attribute(
+                            "agent.reasoning_effort", _applied_effort
+                        )
 
                     # Two retry classes wrap the turn: transient API errors
                     # (timeout, rate-limit, server error) so a network blip
@@ -1842,6 +1881,7 @@ class Agent:
                         reasoning=turn_result.reasoning,
                         model=getattr(context.llm, "model", None),
                         component=context.last_turn_component,
+                        reasoning_effort=context.last_applied_reasoning_effort,
                         agent_name=self.name,
                     )
 

aisolate_agent-0.3.4/src/aisolate/agent/config/__init__.py

@@ -0,0 +1,15 @@
+"""Configuration module for agent settings."""
+
+from .agent_settings import AgentSettings
+from .state_llm import (
+    StateLLMOverride,
+    resolve_effective_strategy,
+    validate_state_llm_overrides,
+)
+
+__all__ = [
+    "AgentSettings",
+    "StateLLMOverride",
+    "resolve_effective_strategy",
+    "validate_state_llm_overrides",
+]

aisolate_agent-0.3.4/src/aisolate/agent/config/state_llm.py

@@ -0,0 +1,92 @@
+"""Per-graph-node LLM execution overrides.
+
+``StateLLMOverride`` selects the model or full strategy and/or the reasoning
+effort for one graph node. ``validate_state_llm_overrides`` is the public,
+side-effect-free validator: ``Agent.__init__`` calls it, and a consuming
+application's CI can call it against a versioned profile table without
+constructing an ``Agent``. Rationale and contract:
+``docs/architecture/state-llm-profiles.analysis.md``.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List, Mapping, Optional, Sequence, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..core.graph import AgentGraph
+    from ..strategies.llm.base import BaseLLMStrategy
+
+__all__ = [
+    "StateLLMOverride",
+    "resolve_effective_strategy",
+    "validate_state_llm_overrides",
+]
+
+
+@dataclass(frozen=True)
+class StateLLMOverride:
+    """LLM execution override for one graph node.
+
+    Fields are independently optional: ``model`` shallow-clones the agent's
+    base strategy onto another model (same client/endpoint), ``strategy``
+    substitutes a full strategy object (different templates, endpoint, or
+    provider), and ``reasoning_effort`` overrides the hint installed by the
+    state's ``on_enter``. An omitted field inherits the current default.
+    """
+
+    model: Optional[str] = None
+    strategy: Optional["BaseLLMStrategy"] = None
+    reasoning_effort: Optional[str] = None
+
+    def __post_init__(self) -> None:
+        if self.model is not None and self.strategy is not None:
+            raise ValueError("Set model or strategy, not both")
+
+
+def resolve_effective_strategy(
+    base: "BaseLLMStrategy", override: Optional[StateLLMOverride]
+) -> "BaseLLMStrategy":
+    """The strategy a node executes with under ``override`` (pure)."""
+    if override is None:
+        return base
+    if override.strategy is not None:
+        return override.strategy
+    if override.model is not None:
+        return base.with_model(override.model)
+    return base
+
+
+def validate_state_llm_overrides(
+    base_strategy: "BaseLLMStrategy",
+    overrides: Mapping[str, StateLLMOverride],
+    graphs: Sequence["AgentGraph"],
+) -> None:
+    """Validate a full override mapping; raise one error naming every problem.
+
+    Pure and offline: resolves each entry's effective strategy and asks it to
+    validate the effort override, so effort support is checked against the
+    strategy/model that will actually execute. ``graphs`` is every graph the
+    agent can run; a key must name a node in at least one of them.
+    """
+    known_nodes: set = set()
+    for graph in graphs:
+        known_nodes.update(graph.nodes)
+
+    problems: List[str] = []
+    for node, override in overrides.items():
+        if node not in known_nodes:
+            problems.append(
+                f"{node!r}: unknown graph node (known: {sorted(known_nodes)})"
+            )
+        if override.reasoning_effort is not None:
+            resolved = resolve_effective_strategy(base_strategy, override)
+            try:
+                resolved.validate_reasoning_effort_override(
+                    override.reasoning_effort
+                )
+            except ValueError as exc:
+                problems.append(f"{node!r}: {exc}")
+
+    if problems:
+        raise ValueError("Invalid state_llm_overrides: " + "; ".join(problems))

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/core/context.py

@@ -224,6 +224,7 @@ class AgentContext:
         self._last_turn_usage: Optional[TokenUsage] = None
         self._last_turn_component: Optional[str] = None
         self._last_turn_reasoning: Optional[str] = None
+        self._last_applied_reasoning_effort: Optional[str] = None
 
         # Kernel state checkpoint tracking
         self.checkpoint_key: Optional[str] = None
@@ -640,6 +641,20 @@ class AgentContext:
         """Component that acted in the most recent turn (main_agent/critic)."""
         return self._last_turn_component
 
+    def set_last_applied_reasoning_effort(self, effort: Optional[str]) -> None:
+        """Record the effort the strategy applied to this turn's LLM call.
+
+        Set by ``BaseLLMStrategy.generate_response`` at call time — post-turn
+        the graph has already transitioned, so hints no longer describe this
+        turn.
+        """
+        self._last_applied_reasoning_effort = effort
+
+    @property
+    def last_applied_reasoning_effort(self) -> Optional[str]:
+        """Applied effort of the most recent turn's own LLM call, if any."""
+        return self._last_applied_reasoning_effort
+
     def set_last_reasoning(self, reasoning: Optional[str]) -> None:
         """Store the reasoning text from the most recent LLM call."""
         self._last_turn_reasoning = reasoning
@@ -1063,6 +1078,7 @@ class AgentContext:
         self._last_turn_usage = None
         self._last_turn_component = None
         self._last_turn_reasoning = None
+        self._last_applied_reasoning_effort = None
 
         # Capture the node identity BEFORE execution (routing moves it during
         # handle()); the node name is the telemetry key — per-turn usage reads

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/core/events.py

@@ -185,6 +185,7 @@ class TurnCompletedEvent(AgentEvent):
         reasoning: Optional[str] = None,
         model: Optional[str] = None,
         component: Optional[str] = None,
+        reasoning_effort: Optional[str] = None,
         agent_name: str = "",
         sub_conversation_id: Optional[str] = None,
         delegation_id: Optional[str] = None,
@@ -201,6 +202,7 @@ class TurnCompletedEvent(AgentEvent):
         # Which component acted this turn ("main_agent"/"critic"), so
         # consumers can attribute the turn's usage per component live.
         self.component = component
+        self.reasoning_effort = reasoning_effort
         # Instance identity for sub-agent turns (lineage id + invocation id);
         # both None on main-agent turns.
         self.sub_conversation_id = sub_conversation_id

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/core/protocols.py

@@ -23,6 +23,14 @@ class LLMStrategy(Protocol):
         """Generate a response from the LLM based on the agent's history."""
         ...
 
+    def validate_reasoning_effort_override(self, value: str) -> None:
+        """Raise ValueError unless the strategy can honor ``value`` at runtime."""
+        ...
+
+    def applied_reasoning_effort(self, context: "AgentContext") -> Optional[str]:
+        """Provider-native effort this call applies; None = no runtime effort."""
+        ...
+
     def prepare_initial_history(self, context: "AgentContext") -> List["Message"]:
         """Creates the initial message history for the planning phase."""
         ...

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/states/task.py

@@ -7,9 +7,9 @@ markdown checklist, which is written to the ``task.md`` **artifact**
 touches no closed-vocabulary kind; the checklist lives in the workspace manifest
 and persists in the snapshot.
 
-Uses the planning-state model (no ``state_model_overrides`` entry). It is
-sandbox-free — writing an artifact mutates ``context.artifacts`` (a framework
-field), not the sandbox filesystem.
+Runs on the base strategy unless a ``state_llm_overrides`` entry routes it
+elsewhere. It is sandbox-free — writing an artifact mutates
+``context.artifacts`` (a framework field), not the sandbox filesystem.
 """
 
 from typing import List, Optional, TYPE_CHECKING

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/strategies/llm/base.py

@@ -221,6 +221,10 @@ class BaseLLMStrategy:
     - create_tool_response_message() for provider-specific formatting
     - parse_assistant_response() if message structure differs significantly
     - _extract_tool_call_args() for provider-specific argument extraction
+
+    Construction contract: creating a strategy performs no network I/O and
+    needs no live credentials, so configuration validators (e.g.
+    ``validate_state_llm_overrides``) stay runnable in CI.
     """
 
     #: Whether this strategy renders image parts (from the ``multimodal_parts``
@@ -297,6 +301,29 @@ class BaseLLMStrategy:
         clone.model = model
         return clone
 
+    def validate_reasoning_effort_override(self, value: str) -> None:
+        """Raise ValueError unless this strategy can honor ``value`` at runtime.
+
+        Called on the RESOLVED per-node strategy during
+        ``validate_state_llm_overrides`` — before any paid call. The base
+        default rejects, so a strategy that ignores the runtime effort hint
+        can never validate an override it would silently drop.
+        """
+        raise ValueError(
+            f"{type(self).__name__} does not support runtime "
+            f"reasoning-effort overrides (got {value!r})"
+        )
+
+    def applied_reasoning_effort(self, context: "AgentContext") -> Optional[str]:
+        """Provider-native description of the effort this call will apply.
+
+        ``None`` means the strategy applies no runtime effort — telemetry
+        must then record nothing rather than echo the state hint. The
+        vocabulary is provider-native by design; consumers must not assume
+        the OpenAI scale.
+        """
+        return None
+
     # ------------------------------------------------------------------
     # Response generation (template method)
     # ------------------------------------------------------------------
@@ -311,6 +338,12 @@ class BaseLLMStrategy:
         only the provider call in :meth:`_generate`; a strategy that merely
         implements ``_generate`` is fully traced.
         """
+        # Captured at call time: by the time the driver builds the turn
+        # event, the graph has already transitioned and the hints belong to
+        # the next node.
+        context.set_last_applied_reasoning_effort(
+            self.applied_reasoning_effort(context)
+        )
         # Identity attributes make a span self-describing in a mixed trace
         # (main agent + sub-agents share one trace): who asked, from which
         # graph node, on which turn.
@@ -386,13 +419,18 @@ class BaseLLMStrategy:
     def _telemetry_invocation_parameters(
         self, context: "AgentContext"
     ) -> Dict[str, Any]:
-        """State hints recorded as ``llm.invocation_parameters`` on the span."""
-        return {
+        """Call parameters recorded as ``llm.invocation_parameters`` on the span.
+
+        The effort entry is the APPLIED value, not the state hint — a
+        strategy that ignores the hint records no effort at all.
+        """
+        params: Dict[str, Any] = {
             "tool_choice": context.get_state_hint("tool_choice", "auto"),
-            "reasoning_effort": context.get_state_hint(
-                "reasoning_effort", "medium"
-            ),
         }
+        effort = self.applied_reasoning_effort(context)
+        if effort is not None:
+            params["reasoning_effort"] = effort
+        return params
 
     def _telemetry_tools(
         self, context: "AgentContext"
@@ -462,7 +500,7 @@ class BaseLLMStrategy:
         prompt_template = (
             sub_agent_templates.get(f"task.{agent_name}")
             or sub_agent_templates.get("task")
-            or "Create a plan to accomplish this task: {task}"
+            or "Create a plan to accomplish this task: {{ task }}"
         )
         rendered = render_template(
             prompt_template,

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/strategies/llm/harmony.py

@@ -125,7 +125,7 @@ class HarmonyLLMStrategy(BaseLLMStrategy):
     def prepare_initial_history(self, context: "AgentContext") -> List["Message"]:
         """Creates the initial message history for the planning phase."""
         initial_plan_template = self.templates.get("planning", {}).get(
-            "initial_plan", "Create a plan to accomplish this task: {task}"
+            "initial_plan", "Create a plan to accomplish this task: {{ task }}"
         )
 
         initial_plan = self._render_template(
@@ -234,7 +234,7 @@ class HarmonyLLMStrategy(BaseLLMStrategy):
     ) -> List["Message"]:
         """Build planning history with expert context from clarification."""
         initial_plan_template = self.templates.get("planning", {}).get(
-            "initial_plan", "Create a plan to accomplish this task: {task}"
+            "initial_plan", "Create a plan to accomplish this task: {{ task }}"
         )
         initial_plan = self._render_template(
             initial_plan_template,
@@ -308,7 +308,7 @@ class HarmonyLLMStrategy(BaseLLMStrategy):
         """Task-decomposition input for harmony: task + plan → a checklist."""
         template = self.templates.get("task", {}).get(
             "decompose",
-            "Break the plan into a concrete, checkable task list for the task: {task}",
+            "Break the plan into a concrete, checkable task list for the task: {{ task }}",
         )
         instructions = self._render_template(
             template, self._get_template_variables(context)
@@ -413,7 +413,7 @@ class HarmonyLLMStrategy(BaseLLMStrategy):
     ) -> List["Message"]:
         """Build planning history from an already-enriched task brief (Harmony)."""
         initial_plan_template = self.templates.get("planning", {}).get(
-            "initial_plan", "Create a plan to accomplish this task: {task}"
+            "initial_plan", "Create a plan to accomplish this task: {{ task }}"
         )
         initial_plan = self._render_template(
             initial_plan_template,

{aisolate_agent-0.3.2 → aisolate_agent-0.3.4}/src/aisolate/agent/strategies/llm/oai.py

@@ -71,6 +71,21 @@ def _coerce_to_dict(value: Any) -> Dict[str, Any]:
     return {"type": "object", "properties": {}}
 
 
+def _reasoning_by_name(model: str) -> bool:
+    """Name-prefix default for reasoning capability (first-party families).
+
+    Heterogeneous OpenAI-compatible catalogs (e.g. Azure AI Foundry hosting
+    DeepSeek/Qwen/Kimi models) defeat any name heuristic — callers declare
+    the capability via the ``reasoning_model`` constructor argument instead.
+    """
+    return (
+        model.startswith("o1-")
+        or model.startswith("o3-")
+        or model.startswith("o4-")
+        or model.startswith("gpt-5")
+    )
+
+
 class OpenAILLMStrategy(BaseLLMStrategy):
     """Provider strategy that bridges OpenAI's Responses API with internal message models."""
 
@@ -100,6 +115,7 @@ class OpenAILLMStrategy(BaseLLMStrategy):
         azure_api_version: Optional[str] = None,
         request_timeout: float = 300.0,
         request_max_retries: int = 2,
+        reasoning_model: Optional[bool] = None,
     ) -> None:
         super().__init__(
             templates=templates,
@@ -140,12 +156,14 @@ class OpenAILLMStrategy(BaseLLMStrategy):
         self.azure_api_version = azure_api_version
         self.is_o1_model = self.model.startswith("o1-")
 
-        # Reasoning models support the reasoning.effort parameter
+        # Reasoning models support the reasoning.effort parameter. An
+        # explicit declaration wins over the name heuristic and survives
+        # with_model cloning.
+        self._reasoning_declared = reasoning_model
         self.is_reasoning_model = (
-            self.model.startswith("o1-")
-            or self.model.startswith("o3-")
-            or self.model.startswith("o4-")
-            or self.model.startswith("gpt-5")
+            reasoning_model
+            if reasoning_model is not None
+            else _reasoning_by_name(self.model)
         )
 
     # ------------------------------------------------------------------
@@ -160,10 +178,9 @@ class OpenAILLMStrategy(BaseLLMStrategy):
         clone.model = model
         clone.is_o1_model = model.startswith("o1-")
         clone.is_reasoning_model = (
-            model.startswith("o1-")
-            or model.startswith("o3-")
-            or model.startswith("o4-")
-            or model.startswith("gpt-5")
+            self._reasoning_declared
+            if self._reasoning_declared is not None
+            else _reasoning_by_name(model)
         )
         if api_version is not None:
             clone.azure_api_version = api_version
@@ -185,6 +202,28 @@ class OpenAILLMStrategy(BaseLLMStrategy):
             )
         return clone
 
+    #: Provider's documented effort vocabulary — owned here, never in core.
+    _EFFORT_VALUES = frozenset({"none", "low", "medium", "high", "xhigh", "max"})
+
+    def validate_reasoning_effort_override(self, value: str) -> None:
+        if not self.is_reasoning_model:
+            raise ValueError(
+                f"model {self.model!r} is not reasoning-capable; a "
+                "reasoning-effort override would be silently dropped "
+                "(declare reasoning_model=True if the catalog model does "
+                "reason)"
+            )
+        if value not in self._EFFORT_VALUES:
+            raise ValueError(
+                f"unsupported reasoning effort {value!r} "
+                f"(known: {sorted(self._EFFORT_VALUES)})"
+            )
+
+    def applied_reasoning_effort(self, context: "AgentContext") -> Optional[str]:
+        if not self.is_reasoning_model:
+            return None
+        return context.get_state_hint("reasoning_effort", "medium")
+
     async def _generate(self, context: "AgentContext") -> LLMResponse:
         history = context.get_conversation_messages()
         serialized_history = self._serialize_history(history)
@@ -295,7 +334,7 @@ class OpenAILLMStrategy(BaseLLMStrategy):
     def prepare_initial_history(self, context: "AgentContext") -> List[Message]:
         template = (
             self.templates.get("planning", {}).get("initial_plan")
-            or "Create a plan to accomplish this task: {task}"
+            or "Create a plan to accomplish this task: {{ task }}"
         )
         initial_plan = self._render_template(
             template,
@@ -354,7 +393,7 @@ class OpenAILLMStrategy(BaseLLMStrategy):
         """
         template = (
             self.templates.get("planning", {}).get("initial_plan")
-            or "Create a plan to accomplish this task: {task}"
+            or "Create a plan to accomplish this task: {{ task }}"
         )
         system_prompt = self._render_template(
             template,
@@ -429,7 +468,7 @@ class OpenAILLMStrategy(BaseLLMStrategy):
         """
         template = (
             self.templates.get("task", {}).get("decompose")
-            or "Break the plan into a concrete, checkable task list for the task: {task}"
+            or "Break the plan into a concrete, checkable task list for the task: {{ task }}"
         )
         system_prompt = self._render_template(
             template,
@@ -530,7 +569,7 @@ class OpenAILLMStrategy(BaseLLMStrategy):
         """
         template = (
             self.templates.get("planning", {}).get("initial_plan")
-            or "Create a plan to accomplish this task: {task}"
+            or "Create a plan to accomplish this task: {{ task }}"
         )
         system_prompt = self._render_template(
             template,