abstractagent 0.2.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

abstractagent/agents/__init__.py

@@ -3,6 +3,7 @@
 from .base import BaseAgent
 from .react import ReactAgent, create_react_workflow, create_react_agent
 from .codeact import CodeActAgent, create_codeact_workflow, create_codeact_agent
+from .memact import MemActAgent, create_memact_workflow, create_memact_agent
 
 __all__ = [
     "BaseAgent",
@@ -12,4 +13,7 @@ __all__ = [
     "CodeActAgent",
     "create_codeact_workflow",
     "create_codeact_agent",
+    "MemActAgent",
+    "create_memact_workflow",
+    "create_memact_agent",
 ]

abstractagent/agents/base.py

@@ -49,11 +49,58 @@ class BaseAgent(ABC):
         self.tools = tools or []
         self.on_step = on_step
         self.workflow = self._create_workflow()
+        self._ensure_workflow_registered()
         self._current_run_id: Optional[str] = None
         self.actor_id: Optional[str] = actor_id
         self.session_id: Optional[str] = session_id
         self.session_messages: List[Dict[str, Any]] = []
 
+    def _ensure_workflow_registered(self) -> None:
+        """Ensure this agent's workflow is registered for subworkflow composition.
+
+        START_SUBWORKFLOW requires a runtime workflow_registry. Registering here keeps
+        agent-created runtimes usable for delegation/subflows without extra host wiring.
+        """
+        try:
+            wf = getattr(self, "workflow", None)
+            wid = getattr(wf, "workflow_id", None)
+            if not isinstance(wid, str) or not wid.strip():
+                return
+
+            reg = getattr(self.runtime, "workflow_registry", None)
+            if reg is None:
+                from abstractruntime.scheduler.registry import WorkflowRegistry
+
+                reg = WorkflowRegistry()
+                setter = getattr(self.runtime, "set_workflow_registry", None)
+                if callable(setter):
+                    setter(reg)
+            getter = getattr(reg, "get", None)
+            if callable(getter) and getter(wid) is not None:
+                return
+            register = getattr(reg, "register", None)
+            if callable(register):
+                register(wf)
+        except Exception:
+            # Never block agent creation due to registry wiring; hosts can still inject their own registry.
+            return
+
+    def _sync_session_caches_from_state(self, state: Optional[RunState]) -> None:
+        if state is None or not hasattr(state, "vars") or not isinstance(state.vars, dict):
+            return
+
+        messages: Optional[List[Dict[str, Any]]] = None
+        output = getattr(state, "output", None)
+        if isinstance(output, dict) and isinstance(output.get("messages"), list):
+            messages = [dict(m) for m in output["messages"] if isinstance(m, dict)]
+        else:
+            ctx = state.vars.get("context")
+            if isinstance(ctx, dict) and isinstance(ctx.get("messages"), list):
+                messages = [dict(m) for m in ctx["messages"] if isinstance(m, dict)]
+
+        if messages is not None:
+            self.session_messages = list(messages)
+
     def _ensure_actor_id(self) -> str:
         if self.actor_id:
             return self.actor_id
@@ -135,6 +182,43 @@ class BaseAgent(ABC):
         if not self._current_run_id:
             return None
         return self.runtime.get_state(self._current_run_id)
+
+    def get_context(self) -> Dict[str, Any]:
+        """Get the agent's current context namespace (runtime-owned persisted state)."""
+        state = self.get_state()
+        ctx = state.vars.get("context") if state and hasattr(state, "vars") else None
+        return dict(ctx) if isinstance(ctx, dict) else {}
+
+    def get_scratchpad(self) -> Dict[str, Any]:
+        """Get the agent's current scratchpad namespace (agent-owned schema, runtime-owned storage)."""
+        state = self.get_state()
+        scratch = state.vars.get("scratchpad") if state and hasattr(state, "vars") else None
+        return dict(scratch) if isinstance(scratch, dict) else {}
+
+    def get_node_traces(self) -> Dict[str, Any]:
+        """Get runtime-owned per-node traces for the current run (passthrough to Runtime)."""
+        if not self._current_run_id:
+            return {}
+        getter = getattr(self.runtime, "get_node_traces", None)
+        if callable(getter):
+            return getter(self._current_run_id)
+        state = self.get_state()
+        runtime_ns = state.vars.get("_runtime") if state and hasattr(state, "vars") else None
+        traces = runtime_ns.get("node_traces") if isinstance(runtime_ns, dict) else None
+        return dict(traces) if isinstance(traces, dict) else {}
+
+    def get_node_trace(self, node_id: str) -> Dict[str, Any]:
+        """Get a single runtime-owned node trace for the current run."""
+        if not self._current_run_id:
+            return {"node_id": node_id, "steps": []}
+        getter = getattr(self.runtime, "get_node_trace", None)
+        if callable(getter):
+            return getter(self._current_run_id, node_id)
+        traces = self.get_node_traces()
+        trace = traces.get(node_id)
+        if isinstance(trace, dict):
+            return trace
+        return {"node_id": node_id, "steps": []}
     
     def is_waiting(self) -> bool:
         """Check if agent is waiting for input.
@@ -199,12 +283,15 @@ class BaseAgent(ABC):
         
         wait_key = state.waiting.wait_key if state.waiting else None
         
-        return self.runtime.resume(
+        state2 = self.runtime.resume(
             workflow=self.workflow,
             run_id=self._current_run_id,
             wait_key=wait_key,
             payload={"response": response},
         )
+        if state2.status in (RunStatus.COMPLETED, RunStatus.FAILED, RunStatus.CANCELLED):
+            self._sync_session_caches_from_state(state2)
+        return state2
     
     def attach(self, run_id: str) -> RunState:
         """Attach to an existing run for resume.
@@ -238,6 +325,7 @@ class BaseAgent(ABC):
             self.session_id = state_session_id
 
         self._current_run_id = run_id
+        self._sync_session_caches_from_state(state)
         return state
     
     def save_state(self, filepath: str) -> None:

abstractagent/agents/codeact.py

@@ -5,11 +5,20 @@ from __future__ import annotations
 from typing import Any, Callable, Dict, List, Optional
 
 from abstractcore.tools import ToolDefinition
-from abstractruntime import RunState, Runtime, WorkflowSpec
+from abstractruntime import RunState, RunStatus, Runtime, WorkflowSpec
 
 from .base import BaseAgent
 from ..adapters.codeact_runtime import create_codeact_workflow
-from ..logic.builtins import ASK_USER_TOOL
+from ..logic.builtins import (
+    ASK_USER_TOOL,
+    COMPACT_MEMORY_TOOL,
+    DELEGATE_AGENT_TOOL,
+    INSPECT_VARS_TOOL,
+    OPEN_ATTACHMENT_TOOL,
+    RECALL_MEMORY_TOOL,
+    REMEMBER_TOOL,
+    REMEMBER_NOTE_TOOL,
+)
 from ..logic.codeact import CodeActLogic
 
 
@@ -44,7 +53,10 @@ class CodeActAgent(BaseAgent):
         on_step: Optional[Callable[[str, Dict[str, Any]], None]] = None,
         max_iterations: int = 25,
         max_history_messages: int = -1,
-        max_tokens: Optional[int] = 32768,
+        max_tokens: Optional[int] = None,
+        plan_mode: bool = False,
+        review_mode: bool = True,
+        review_max_rounds: int = 3,
         actor_id: Optional[str] = None,
         session_id: Optional[str] = None,
     ):
@@ -56,6 +68,11 @@ class CodeActAgent(BaseAgent):
         if self._max_history_messages != -1 and self._max_history_messages < 1:
             self._max_history_messages = 1
         self._max_tokens = max_tokens
+        self._plan_mode = bool(plan_mode)
+        self._review_mode = bool(review_mode)
+        self._review_max_rounds = int(review_max_rounds)
+        if self._review_max_rounds < 0:
+            self._review_max_rounds = 0
 
         self.logic: Optional[CodeActLogic] = None
         super().__init__(
@@ -68,7 +85,17 @@ class CodeActAgent(BaseAgent):
 
     def _create_workflow(self) -> WorkflowSpec:
         tool_defs = _tool_definitions_from_callables(self.tools)
-        tool_defs = [ASK_USER_TOOL, *tool_defs]
+        tool_defs = [
+            ASK_USER_TOOL,
+            OPEN_ATTACHMENT_TOOL,
+            RECALL_MEMORY_TOOL,
+            INSPECT_VARS_TOOL,
+            REMEMBER_TOOL,
+            REMEMBER_NOTE_TOOL,
+            COMPACT_MEMORY_TOOL,
+            DELEGATE_AGENT_TOOL,
+            *tool_defs,
+        ]
         logic = CodeActLogic(
             tools=tool_defs,
             max_history_messages=self._max_history_messages,
@@ -77,27 +104,99 @@ class CodeActAgent(BaseAgent):
         self.logic = logic
         return create_codeact_workflow(logic=logic, on_step=self.on_step)
 
-    def start(self, task: str) -> str:
+    def start(
+        self,
+        task: str,
+        *,
+        plan_mode: Optional[bool] = None,
+        review_mode: Optional[bool] = None,
+        review_max_rounds: Optional[int] = None,
+        allowed_tools: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        seed: Optional[int] = None,
+        attachments: Optional[List[Any]] = None,
+    ) -> str:
         task = str(task or "").strip()
         if not task:
             raise ValueError("task must be a non-empty string")
 
+        eff_plan_mode = self._plan_mode if plan_mode is None else bool(plan_mode)
+        eff_review_mode = self._review_mode if review_mode is None else bool(review_mode)
+        eff_review_max_rounds = self._review_max_rounds if review_max_rounds is None else int(review_max_rounds)
+        if eff_review_max_rounds < 0:
+            eff_review_max_rounds = 0
+
+        # Base limits come from the Runtime config so model capabilities (max context)
+        # are respected by default, unless explicitly overridden by the agent/session.
+        try:
+            base_limits = dict(self.runtime.config.to_limits_dict())
+        except Exception:
+            base_limits = {}
+        limits: Dict[str, Any] = dict(base_limits)
+        limits.setdefault("warn_iterations_pct", 80)
+        limits.setdefault("warn_tokens_pct", 80)
+        limits["max_iterations"] = int(self._max_iterations)
+        limits["current_iteration"] = 0
+        limits["max_history_messages"] = int(self._max_history_messages)
+        # Message-size guards for LLM-visible context (character-level).
+        # Disabled by default (-1): enable by setting a positive character budget.
+        limits.setdefault("max_message_chars", -1)
+        limits.setdefault("max_tool_message_chars", -1)
+        limits["estimated_tokens_used"] = 0
+        try:
+            max_tokens_override = int(self._max_tokens) if self._max_tokens is not None else None
+        except Exception:
+            max_tokens_override = None
+        if isinstance(max_tokens_override, int) and max_tokens_override > 0:
+            limits["max_tokens"] = max_tokens_override
+        if not isinstance(limits.get("max_tokens"), int) or int(limits.get("max_tokens") or 0) <= 0:
+            limits["max_tokens"] = 32768
+
         vars: Dict[str, Any] = {
             "context": {"task": task, "messages": _copy_messages(self.session_messages)},
             "scratchpad": {"iteration": 0, "max_iterations": int(self._max_iterations)},
-            "_runtime": {"inbox": []},
+            "_runtime": {
+                "inbox": [],
+                "plan_mode": eff_plan_mode,
+                "review_mode": eff_review_mode,
+                "review_max_rounds": eff_review_max_rounds,
+            },
             "_temp": {},
             # Canonical _limits namespace for runtime awareness
-            "_limits": {
-                "max_iterations": int(self._max_iterations),
-                "current_iteration": 0,
-                "max_tokens": self._max_tokens,
-                "max_history_messages": int(self._max_history_messages),
-                "estimated_tokens_used": 0,
-                "warn_iterations_pct": 80,
-                "warn_tokens_pct": 80,
-            },
+            "_limits": limits,
         }
+        if temperature is not None:
+            try:
+                vars["_runtime"]["temperature"] = float(temperature)
+            except Exception:
+                pass
+        if seed is not None:
+            try:
+                vars["_runtime"]["seed"] = int(seed)
+            except Exception:
+                pass
+        if isinstance(allowed_tools, list):
+            normalized = [str(t).strip() for t in allowed_tools if isinstance(t, str) and t.strip()]
+            vars["_runtime"]["allowed_tools"] = normalized
+        if attachments:
+            items: list[Any]
+            if isinstance(attachments, tuple):
+                items = list(attachments)
+            else:
+                items = attachments if isinstance(attachments, list) else []
+            normalized: list[Any] = []
+            for item in items:
+                if isinstance(item, str) and item.strip():
+                    normalized.append(item.strip())
+                    continue
+                if isinstance(item, dict):
+                    aid = item.get("$artifact")
+                    if not (isinstance(aid, str) and aid.strip()):
+                        aid = item.get("artifact_id")
+                    if isinstance(aid, str) and aid.strip():
+                        normalized.append(dict(item))
+            if normalized:
+                vars["context"]["attachments"] = normalized
 
         run_id = self.runtime.start(
             workflow=self.workflow,
@@ -142,7 +241,10 @@ class CodeActAgent(BaseAgent):
     def step(self) -> RunState:
         if not self._current_run_id:
             raise RuntimeError("No active run. Call start() first.")
-        return self.runtime.tick(workflow=self.workflow, run_id=self._current_run_id, max_steps=1)
+        state = self.runtime.tick(workflow=self.workflow, run_id=self._current_run_id, max_steps=1)
+        if state.status in (RunStatus.COMPLETED, RunStatus.FAILED, RunStatus.CANCELLED):
+            self._sync_session_caches_from_state(state)
+        return state
 
 
 def create_codeact_agent(
@@ -153,7 +255,10 @@ def create_codeact_agent(
     on_step: Optional[Callable[[str, Dict[str, Any]], None]] = None,
     max_iterations: int = 25,
     max_history_messages: int = -1,
-    max_tokens: Optional[int] = 32768,
+    max_tokens: Optional[int] = None,
+    plan_mode: bool = False,
+    review_mode: bool = True,
+    review_max_rounds: int = 3,
     llm_kwargs: Optional[Dict[str, Any]] = None,
     run_store: Optional[Any] = None,
     ledger_store: Optional[Any] = None,
@@ -185,10 +290,12 @@ def create_codeact_agent(
         max_iterations=max_iterations,
         max_history_messages=max_history_messages,
         max_tokens=max_tokens,
+        plan_mode=plan_mode,
+        review_mode=review_mode,
+        review_max_rounds=review_max_rounds,
         actor_id=actor_id,
         session_id=session_id,
     )
 
 
 __all__ = ["CodeActAgent", "create_codeact_workflow", "create_codeact_agent"]
-

abstractagent/agents/memact.py

@@ -0,0 +1,280 @@
+"""MemAct agent implementation (memory-enhanced).
+
+MemAct is the only agent that uses `abstractruntime.memory.active_memory`.
+ReAct and CodeAct remain conventional SOTA agents.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Callable, Dict, List, Optional
+
+from abstractcore.tools import ToolDefinition
+from abstractruntime import RunState, RunStatus, Runtime, WorkflowSpec
+
+from .base import BaseAgent
+from ..adapters.memact_runtime import create_memact_workflow
+from ..logic.builtins import (
+    ASK_USER_TOOL,
+    COMPACT_MEMORY_TOOL,
+    DELEGATE_AGENT_TOOL,
+    INSPECT_VARS_TOOL,
+    OPEN_ATTACHMENT_TOOL,
+    RECALL_MEMORY_TOOL,
+    REMEMBER_TOOL,
+    REMEMBER_NOTE_TOOL,
+)
+from ..logic.memact import MemActLogic
+
+
+def _tool_definitions_from_callables(tools: List[Callable[..., Any]]) -> List[ToolDefinition]:
+    tool_defs: List[ToolDefinition] = []
+    for t in tools:
+        tool_def = getattr(t, "_tool_definition", None)
+        if tool_def is None:
+            tool_def = ToolDefinition.from_function(t)
+        tool_defs.append(tool_def)
+    return tool_defs
+
+
+def _copy_messages(messages: Any) -> List[Dict[str, Any]]:
+    if not isinstance(messages, list):
+        return []
+    out: List[Dict[str, Any]] = []
+    for m in messages:
+        if isinstance(m, dict):
+            out.append(dict(m))
+    return out
+
+
+def _deepcopy_json(value: Any) -> Any:
+    try:
+        return json.loads(json.dumps(value))
+    except Exception:
+        return value
+
+
+class MemActAgent(BaseAgent):
+    """Memory-enhanced agent with runtime-owned Active Memory blocks."""
+
+    def __init__(
+        self,
+        *,
+        runtime: Runtime,
+        tools: Optional[List[Callable[..., Any]]] = None,
+        on_step: Optional[Callable[[str, Dict[str, Any]], None]] = None,
+        max_iterations: int = 25,
+        max_history_messages: int = -1,
+        max_tokens: Optional[int] = None,
+        plan_mode: bool = False,
+        review_mode: bool = False,
+        review_max_rounds: int = 1,
+        actor_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+    ):
+        self._max_iterations = int(max_iterations)
+        if self._max_iterations < 1:
+            self._max_iterations = 1
+        self._max_history_messages = int(max_history_messages)
+        if self._max_history_messages != -1 and self._max_history_messages < 1:
+            self._max_history_messages = 1
+        self._max_tokens = max_tokens
+        self._plan_mode = bool(plan_mode)
+        self._review_mode = bool(review_mode)
+        self._review_max_rounds = int(review_max_rounds)
+        if self._review_max_rounds < 0:
+            self._review_max_rounds = 0
+
+        self.logic: Optional[MemActLogic] = None
+        self.session_active_memory: Optional[Dict[str, Any]] = None
+        super().__init__(
+            runtime=runtime,
+            tools=tools,
+            on_step=on_step,
+            actor_id=actor_id,
+            session_id=session_id,
+        )
+
+    def _create_workflow(self) -> WorkflowSpec:
+        tool_defs = _tool_definitions_from_callables(self.tools)
+        tool_defs = [
+            ASK_USER_TOOL,
+            OPEN_ATTACHMENT_TOOL,
+            RECALL_MEMORY_TOOL,
+            INSPECT_VARS_TOOL,
+            REMEMBER_TOOL,
+            REMEMBER_NOTE_TOOL,
+            COMPACT_MEMORY_TOOL,
+            DELEGATE_AGENT_TOOL,
+            *tool_defs,
+        ]
+        logic = MemActLogic(
+            tools=tool_defs,
+            max_history_messages=self._max_history_messages,
+            max_tokens=self._max_tokens,
+        )
+        self.logic = logic
+        return create_memact_workflow(logic=logic, on_step=self.on_step)
+
+    def _sync_session_caches_from_state(self, state: Optional[RunState]) -> None:
+        super()._sync_session_caches_from_state(state)
+        if state is None or not hasattr(state, "vars") or not isinstance(state.vars, dict):
+            return
+        runtime_ns = state.vars.get("_runtime")
+        if not isinstance(runtime_ns, dict):
+            return
+        mem = runtime_ns.get("active_memory")
+        if isinstance(mem, dict):
+            self.session_active_memory = _deepcopy_json(mem)
+
+    def start(
+        self,
+        task: str,
+        *,
+        plan_mode: Optional[bool] = None,
+        review_mode: Optional[bool] = None,
+        review_max_rounds: Optional[int] = None,
+        allowed_tools: Optional[List[str]] = None,
+        temperature: Optional[float] = None,
+        seed: Optional[int] = None,
+        attachments: Optional[List[Any]] = None,
+    ) -> str:
+        task = str(task or "").strip()
+        if not task:
+            raise ValueError("task must be a non-empty string")
+
+        try:
+            base_limits = dict(self.runtime.config.to_limits_dict())
+        except Exception:
+            base_limits = {}
+        limits: Dict[str, Any] = dict(base_limits)
+        limits.setdefault("warn_iterations_pct", 80)
+        limits.setdefault("warn_tokens_pct", 80)
+        limits["max_iterations"] = int(self._max_iterations)
+        limits["current_iteration"] = 0
+        limits["max_history_messages"] = int(self._max_history_messages)
+        limits["estimated_tokens_used"] = 0
+        try:
+            max_tokens_override = int(self._max_tokens) if self._max_tokens is not None else None
+        except Exception:
+            max_tokens_override = None
+        if isinstance(max_tokens_override, int) and max_tokens_override > 0:
+            limits["max_tokens"] = max_tokens_override
+        if not isinstance(limits.get("max_tokens"), int) or int(limits.get("max_tokens") or 0) <= 0:
+            limits["max_tokens"] = 32768
+
+        eff_plan_mode = self._plan_mode if plan_mode is None else bool(plan_mode)
+        eff_review_mode = self._review_mode if review_mode is None else bool(review_mode)
+        eff_review_max_rounds = self._review_max_rounds if review_max_rounds is None else int(review_max_rounds)
+        if eff_review_max_rounds < 0:
+            eff_review_max_rounds = 0
+
+        runtime_ns: Dict[str, Any] = {
+            "inbox": [],
+            "plan_mode": eff_plan_mode,
+            "review_mode": eff_review_mode,
+            "review_max_rounds": eff_review_max_rounds,
+        }
+        if temperature is not None:
+            try:
+                runtime_ns["temperature"] = float(temperature)
+            except Exception:
+                pass
+        if seed is not None:
+            try:
+                runtime_ns["seed"] = int(seed)
+            except Exception:
+                pass
+        if isinstance(self.session_active_memory, dict):
+            runtime_ns["active_memory"] = _deepcopy_json(self.session_active_memory)
+        if isinstance(allowed_tools, list):
+            normalized = [str(t).strip() for t in allowed_tools if isinstance(t, str) and t.strip()]
+            runtime_ns["allowed_tools"] = normalized
+
+        vars: Dict[str, Any] = {
+            "context": {"task": task, "messages": _copy_messages(self.session_messages)},
+            "scratchpad": {"iteration": 0, "max_iterations": int(self._max_iterations)},
+            "_runtime": runtime_ns,
+            "_temp": {},
+            "_limits": limits,
+        }
+        if attachments:
+            items: list[Any]
+            if isinstance(attachments, tuple):
+                items = list(attachments)
+            else:
+                items = attachments if isinstance(attachments, list) else []
+            normalized: list[Any] = []
+            for item in items:
+                if isinstance(item, str) and item.strip():
+                    normalized.append(item.strip())
+                    continue
+                if isinstance(item, dict):
+                    aid = item.get("$artifact")
+                    if not (isinstance(aid, str) and aid.strip()):
+                        aid = item.get("artifact_id")
+                    if isinstance(aid, str) and aid.strip():
+                        normalized.append(dict(item))
+            if normalized:
+                vars["context"]["attachments"] = normalized
+
+        run_id = self.runtime.start(
+            workflow=self.workflow,
+            vars=vars,
+            actor_id=self._ensure_actor_id(),
+            session_id=self._ensure_session_id(),
+        )
+        self._current_run_id = run_id
+        return run_id
+
+    def step(self) -> RunState:
+        if not self._current_run_id:
+            raise RuntimeError("No active run. Call start() first.")
+        state = self.runtime.tick(workflow=self.workflow, run_id=self._current_run_id, max_steps=1)
+        if state.status in (RunStatus.COMPLETED, RunStatus.FAILED, RunStatus.CANCELLED):
+            self._sync_session_caches_from_state(state)
+        return state
+
+
+def create_memact_agent(
+    *,
+    provider: str = "ollama",
+    model: str = "qwen3:1.7b-q4_K_M",
+    tools: Optional[List[Callable[..., Any]]] = None,
+    on_step: Optional[Callable[[str, Dict[str, Any]], None]] = None,
+    max_iterations: int = 25,
+    max_history_messages: int = -1,
+    max_tokens: Optional[int] = None,
+    llm_kwargs: Optional[Dict[str, Any]] = None,
+    run_store: Optional[Any] = None,
+    ledger_store: Optional[Any] = None,
+    actor_id: Optional[str] = None,
+    session_id: Optional[str] = None,
+) -> MemActAgent:
+    """Factory: create a MemActAgent with a local AbstractCore-backed runtime."""
+
+    from abstractruntime.integrations.abstractcore import MappingToolExecutor, create_local_runtime
+
+    if tools is None:
+        from ..tools import ALL_TOOLS
+
+        tools = list(ALL_TOOLS)
+
+    runtime = create_local_runtime(
+        provider=provider,
+        model=model,
+        llm_kwargs=llm_kwargs,
+        tool_executor=MappingToolExecutor.from_tools(list(tools)),
+        run_store=run_store,
+        ledger_store=ledger_store,
+    )
+    return MemActAgent(
+        runtime=runtime,
+        tools=tools,
+        on_step=on_step,
+        max_iterations=max_iterations,
+        max_history_messages=max_history_messages,
+        max_tokens=max_tokens,
+        actor_id=actor_id,
+        session_id=session_id,
+    )