npm - flowent - Versions diffs - 0.3.3 → 0.3.4 - Mend

flowent 0.3.3 → 0.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (25) hide show

package/README.md +3 -0
package/backend/README.md +3 -0
package/backend/pyproject.toml +1 -1
package/backend/src/flowent/agent.py +1 -1
package/backend/src/flowent/agent_runtime.py +220 -0
package/backend/src/flowent/api_models.py +9 -1
package/backend/src/flowent/app.py +2 -0
package/backend/src/flowent/routes/workflow_routes.py +15 -3
package/backend/src/flowent/state/models.py +1 -1
package/backend/src/flowent/static/assets/index-ByGH1ZWH.css +2 -0
package/backend/src/flowent/static/assets/index-D3WSbctU.js +98 -0
package/backend/src/flowent/static/index.html +2 -2
package/backend/src/flowent/workflow_service.py +24 -2
package/backend/src/flowent/workflow_tools.py +16 -8
package/backend/src/flowent/workflows.py +113 -18
package/backend/src/flowent/workspace/runtime.py +50 -124
package/backend/uv.lock +1 -1
package/dist/frontend/assets/index-ByGH1ZWH.css +2 -0
package/dist/frontend/assets/index-D3WSbctU.js +98 -0
package/dist/frontend/index.html +2 -2
package/package.json +1 -1
package/backend/src/flowent/static/assets/index-CCf0mo80.css +0 -2
package/backend/src/flowent/static/assets/index-CROofCFl.js +0 -102
package/dist/frontend/assets/index-CCf0mo80.css +0 -2
package/dist/frontend/assets/index-CROofCFl.js +0 -102

package/backend/src/flowent/static/index.html CHANGED Viewed

@@ -6,8 +6,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Flowent</title>
     <meta name="description" content="Flowent application" />
-    <script type="module" crossorigin src="/assets/index-CROofCFl.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-CCf0mo80.css">
+    <script type="module" crossorigin src="/assets/index-D3WSbctU.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-ByGH1ZWH.css">
   </head>
   <body>
     <div id="root"></div>

package/backend/src/flowent/workflow_service.py CHANGED Viewed

@@ -1,8 +1,11 @@
 from __future__ import annotations
 from collections.abc import Mapping
+from pathlib import Path
+from flowent.agent_runtime import FlowentAgentRuntime
 from flowent.llm import CompletionCallable
+from flowent.mcp import McpManager
 from flowent.provider_connections import selected_connection
 from flowent.storage import StateStore, StoredWorkflow, StoredWorkflowDefinition
 from flowent.workflows import (
@@ -18,10 +21,21 @@ class WorkflowService:
         self,
         *,
         chat_completion: CompletionCallable | None,
+        cwd: Path,
+        mcp_manager: McpManager,
         store: StateStore,
     ) -> None:
         self.chat_completion = chat_completion
+        self.cwd = cwd
+        self.mcp_manager = mcp_manager
         self.store = store
+        self.agent_runtime = FlowentAgentRuntime(
+            chat_completion=chat_completion,
+            cwd=cwd,
+            mcp_manager=mcp_manager,
+            store=store,
+            workflow_service=self,
+        )
     def list_workflows(self) -> list[StoredWorkflow]:
         return self.store.read_workflows()
@@ -54,6 +68,8 @@ class WorkflowService:
         *,
         default_input: str = "",
         input_values: Mapping[str, str] | None = None,
+        timer_node_id: str = "",
+        workflow_depth: int = 0,
     ) -> WorkflowRunResponse:
         workflow = self.get_workflow(workflow_id)
         connection = (
@@ -62,11 +78,13 @@ class WorkflowService:
             else None
         )
         return await run_workflow_definition(
-            completion=self.chat_completion,
             connection=connection,
             default_input=default_input,
             definition=workflow.definition,
             input_values=input_values,
+            runtime=self.agent_runtime,
+            timer_node_id=timer_node_id,
+            workflow_depth=workflow_depth,
             workflow_id=workflow.id,
         )
@@ -76,6 +94,8 @@ class WorkflowService:
         default_input: str = "",
         definition: StoredWorkflowDefinition,
         input_values: Mapping[str, str] | None = None,
+        timer_node_id: str = "",
+        workflow_depth: int = 0,
         workflow_id: str,
     ) -> WorkflowRunResponse:
         connection = (
@@ -84,10 +104,12 @@ class WorkflowService:
             else None
         )
         return await run_workflow_definition(
-            completion=self.chat_completion,
             connection=connection,
             default_input=default_input,
             definition=definition,
             input_values=input_values,
+            runtime=self.agent_runtime,
+            timer_node_id=timer_node_id,
+            workflow_depth=workflow_depth,
             workflow_id=workflow_id,
         )

package/backend/src/flowent/workflow_tools.py CHANGED Viewed

@@ -1,12 +1,19 @@
 from __future__ import annotations
+from typing import TYPE_CHECKING
+from uuid import uuid4
 from pydantic import ValidationError
 from flowent.storage import StoredWorkflow
 from flowent.tools import ToolResult, text_tool_result
-from flowent.workflow_service import WorkflowService
 from flowent.workflows import WorkflowRunResponse
+if TYPE_CHECKING:
+    from flowent.workflow_service import WorkflowService
+MAX_WORKFLOW_TOOL_DEPTH = 3
 def workflow_tool_specs() -> list[dict[str, object]]:
     workflow_schema: dict[str, object] = {"type": "object"}
@@ -92,8 +99,9 @@ def workflow_tool_title(name: str) -> str | None:
 class WorkflowAgentTools:
-    def __init__(self, service: WorkflowService) -> None:
+    def __init__(self, service: WorkflowService, *, workflow_depth: int = 0) -> None:
         self.service = service
+        self.workflow_depth = workflow_depth
     async def run_tool(
         self, name: str, arguments: dict[str, object]
@@ -157,12 +165,15 @@ class WorkflowAgentTools:
         )
     async def run_workflow(self, arguments: dict[str, object]) -> ToolResult:
+        if self.workflow_depth >= MAX_WORKFLOW_TOOL_DEPTH:
+            raise ValueError("Workflow nesting is too deep.")
         workflow_id = str(arguments["workflow_id"])
         workflow = self.service.get_workflow(workflow_id)
         result = await self.service.run_workflow(
             workflow_id,
             default_input=string_argument(arguments, "input"),
             input_values=string_map_argument(arguments, "inputs"),
+            workflow_depth=self.workflow_depth + 1,
         )
         output = workflow_run_output(workflow.name, result)
         return ToolResult(
@@ -184,12 +195,9 @@ class WorkflowAgentTools:
     def create_workflow(self, arguments: dict[str, object]) -> ToolResult:
         workflow = workflow_argument(arguments)
-        try:
-            self.service.get_workflow(workflow.id)
-        except ValueError:
-            saved = self.service.save_workflow(workflow)
-        else:
-            raise ValueError("Workflow already exists.")
+        saved = self.service.save_workflow(
+            workflow.model_copy(update={"id": str(uuid4())})
+        )
         return saved_workflow_result(saved, "Created")
     def update_workflow(self, arguments: dict[str, object]) -> ToolResult:

package/backend/src/flowent/workflows.py CHANGED Viewed

@@ -1,3 +1,5 @@
+from __future__ import annotations
 import json
 import re
 import sys
@@ -5,15 +7,12 @@ import tempfile
 from collections import defaultdict, deque
 from collections.abc import Mapping
 from pathlib import Path
+from typing import TYPE_CHECKING
 from pydantic import BaseModel, ConfigDict, Field
-from flowent.llm import (
-    ChatMessage,
-    CompletionCallable,
-    ProviderConnection,
-    complete_chat,
-)
+from flowent.context import runtime_context_messages
+from flowent.llm import ProviderConnection
 from flowent.sandbox import SandboxRunner
 from flowent.storage import (
     StoredWorkflow,
@@ -22,6 +21,9 @@ from flowent.storage import (
     StoredWorkflowNode,
 )
+if TYPE_CHECKING:
+    from flowent.agent_runtime import FlowentAgentRuntime
 class WorkflowNodeRunResult(BaseModel):
     model_config = ConfigDict(extra="forbid")
@@ -41,6 +43,13 @@ class WorkflowRunResponse(BaseModel):
     workflow_id: str
+class WorkflowRunRequestValues(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    default_input: str = ""
+    input_values: dict[str, str] = Field(default_factory=dict)
 PLACEHOLDER_PATTERN = re.compile(r"\{\{\s*([A-Za-z0-9_.-]+)\.output\s*\}\}")
 PYTHON_CODE_RUNNER = r"""
 import contextlib
@@ -106,8 +115,8 @@ def validate_workflow_definition(definition: StoredWorkflowDefinition) -> list[s
         raise ValueError("Workflow node ids must not be empty.")
     if len(set(node_ids)) != len(node_ids):
         raise ValueError("Workflow node ids must be unique.")
-    if not any(node.type == "input" for node in definition.nodes):
-        raise ValueError("Workflow needs an input node.")
+    if not any(node.type in {"input", "timer"} for node in definition.nodes):
+        raise ValueError("Workflow needs an input or timer node.")
     if not any(node.type == "output" for node in definition.nodes):
         raise ValueError("Workflow needs an output node.")
@@ -129,6 +138,43 @@ def workflow_requires_connection(definition: StoredWorkflowDefinition) -> bool:
     return any(node.type == "agent" for node in definition.nodes)
+def timer_run_node_ids(
+    definition: StoredWorkflowDefinition, timer_node_id: str
+) -> set[str]:
+    nodes = {node.id: node for node in definition.nodes}
+    timer_node = nodes.get(timer_node_id)
+    if timer_node is None or timer_node.type != "timer":
+        raise ValueError("Timer node not found.")
+    outgoing: dict[str, list[str]] = defaultdict(list)
+    incoming: dict[str, list[str]] = defaultdict(list)
+    for edge in definition.edges:
+        outgoing[edge.source].append(edge.target)
+        incoming[edge.target].append(edge.source)
+    active = {timer_node_id}
+    queue = deque([timer_node_id])
+    while queue:
+        node_id = queue.popleft()
+        for target in outgoing[node_id]:
+            if target not in active:
+                active.add(target)
+                queue.append(target)
+    queue = deque(active)
+    while queue:
+        node_id = queue.popleft()
+        for source in incoming[node_id]:
+            source_node = nodes[source]
+            if source_node.type == "timer" and source != timer_node_id:
+                continue
+            if source not in active:
+                active.add(source)
+                queue.append(source)
+    return active
 def topological_node_ids(definition: StoredWorkflowDefinition) -> list[str]:
     node_ids = [node.id for node in definition.nodes]
     outgoing: dict[str, list[str]] = defaultdict(list)
@@ -162,39 +208,73 @@ def topological_node_ids(definition: StoredWorkflowDefinition) -> list[str]:
 async def run_workflow_definition(
     *,
-    completion: CompletionCallable | None,
     connection: ProviderConnection | None,
     definition: StoredWorkflowDefinition,
     default_input: str = "",
     input_values: Mapping[str, str] | None = None,
+    runtime: FlowentAgentRuntime | None = None,
+    timer_node_id: str = "",
+    workflow_depth: int = 0,
     workflow_id: str,
 ) -> WorkflowRunResponse:
     ordered_ids = validate_workflow_definition(definition)
     if workflow_requires_connection(definition) and connection is None:
         raise ValueError("Choose a provider and model before running.")
+    return await run_workflow_once(
+        connection=connection,
+        definition=definition,
+        input_values=WorkflowRunRequestValues(
+            default_input=default_input,
+            input_values=dict(input_values or {}),
+        ),
+        ordered_ids=ordered_ids,
+        runtime=runtime,
+        timer_node_id=timer_node_id,
+        workflow_depth=workflow_depth,
+        workflow_id=workflow_id,
+    )
+async def run_workflow_once(
+    *,
+    connection: ProviderConnection | None,
+    definition: StoredWorkflowDefinition,
+    input_values: WorkflowRunRequestValues,
+    ordered_ids: list[str],
+    runtime: FlowentAgentRuntime | None = None,
+    timer_node_id: str = "",
+    workflow_depth: int = 0,
+    workflow_id: str,
+) -> WorkflowRunResponse:
     nodes = {node.id: node for node in definition.nodes}
     incoming_edges = edges_by_target(definition.edges)
+    active_node_ids = (
+        timer_run_node_ids(definition, timer_node_id) if timer_node_id else None
+    )
     results: dict[str, WorkflowNodeRunResult] = {
         node.id: WorkflowNodeRunResult(id=node.id, status="pending")
         for node in definition.nodes
     }
     outputs: dict[str, str] = {}
     named_outputs: dict[str, str] = {}
-    remaining_default_input = default_input
+    remaining_default_input = input_values.default_input
     for node_id in ordered_ids:
         node = nodes[node_id]
+        if active_node_ids is not None and node.id not in active_node_ids:
+            continue
         results[node.id] = WorkflowNodeRunResult(id=node.id, status="running")
         try:
             output = await run_node(
-                completion=completion,
                 connection=connection,
                 default_input=remaining_default_input,
-                input_values=input_values or {},
+                input_values=input_values.input_values,
                 incoming_edges=incoming_edges[node.id],
                 node=node,
                 outputs=outputs,
+                runtime=runtime,
+                workflow_depth=workflow_depth,
             )
             if node.type == "input" and remaining_default_input:
                 remaining_default_input = ""
@@ -229,13 +309,14 @@ async def run_workflow_definition(
 async def run_node(
     *,
-    completion: CompletionCallable | None,
     connection: ProviderConnection | None,
     default_input: str,
     input_values: Mapping[str, str],
     incoming_edges: list[StoredWorkflowEdge],
     node: StoredWorkflowNode,
     outputs: Mapping[str, str],
+    runtime: FlowentAgentRuntime | None = None,
+    workflow_depth: int = 0,
 ) -> str:
     if node.type == "input":
         if node.id in input_values:
@@ -246,17 +327,25 @@ async def run_node(
     if node.type == "agent":
         if connection is None:
             raise ValueError("Choose a provider and model before running.")
+        if runtime is None:
+            raise ValueError("Agent runtime is not available.")
         prompt = render_template(
             node_data_text(node, "prompt")
             or joined_upstream_outputs(incoming_edges, outputs),
             outputs,
         )
-        response = await complete_chat(
-            connection,
-            [ChatMessage(role="user", content=prompt)],
-            completion=completion,
+        result = await runtime.complete(
+            connection=connection,
+            messages=[
+                *runtime_context_messages(
+                    runtime.cwd, runtime.store.read_state().settings.agent_prompt
+                ),
+                {"role": "user", "content": prompt},
+            ],
+            user_request=prompt,
+            workflow_depth=workflow_depth,
         )
-        return response.content
+        return result.content
     if node.type == "merge":
         upstream = upstream_outputs(incoming_edges, outputs)
         if node_data_text(node, "merge_strategy") == "json":
@@ -264,6 +353,8 @@ async def run_node(
         return "\n".join(output for output in upstream if output)
     if node.type == "code":
         return await run_code_node(node, upstream_outputs(incoming_edges, outputs))
+    if node.type == "timer":
+        return timer_payload(node)
     if node.type == "output":
         return joined_upstream_outputs(incoming_edges, outputs)
     raise ValueError("Node type is not supported.")
@@ -313,6 +404,10 @@ def node_output_key(node: StoredWorkflowNode) -> str:
     return node_data_text(node, "output_key") or node.id
+def timer_payload(node: StoredWorkflowNode) -> str:
+    return node_data_text(node, "payload") or "Timer fired."
 def upstream_outputs(
     incoming_edges: list[StoredWorkflowEdge],
     outputs: Mapping[str, str],

package/backend/src/flowent/workspace/runtime.py CHANGED Viewed

@@ -10,14 +10,13 @@ from uuid import uuid4
 from fastapi import HTTPException
-from flowent.agent import AgentContextUpdate, run_agent_stream
-from flowent.approval import ApprovalReviewRequest, review_approval_request
+from flowent.agent import AgentContextUpdate
+from flowent.agent_runtime import FlowentAgentRuntime
 from flowent.compact import CompactInput, CompactProvider
 from flowent.context import runtime_context_messages
 from flowent.llm import ChatMessage, CompletionCallable, ProviderConnection
 from flowent.logging import TRACE_LEVEL
 from flowent.mcp import McpManager
-from flowent.permissions import run_tool_with_path_permissions
 from flowent.provider_connections import selected_connection
 from flowent.skills import explicit_skill_messages
 from flowent.storage import (
@@ -27,7 +26,7 @@ from flowent.storage import (
     StoredState,
     StoredToolItem,
 )
-from flowent.tools import ToolContext, ToolResult, text_tool_result, tool_specs
+from flowent.tools import text_tool_result
 from flowent.usage import (
     TokenUsage,
     TokenUsageInfo,
@@ -37,11 +36,6 @@ from flowent.usage import (
     recompute_context_usage,
 )
 from flowent.workflow_service import WorkflowService
-from flowent.workflow_tools import (
-    WorkflowAgentTools,
-    workflow_tool_specs,
-    workflow_tool_title,
-)
 from flowent.workspace.context import (
     COMPACTED_CONTEXT_MARKER,
     OPTIMIZED_CONTEXT_MARKER,
@@ -97,38 +91,27 @@ class WorkspaceRuntime:
         self.chat_completion = chat_completion
         self.compact_provider = compact_provider
         self.cwd = cwd
-        self.mcp_manager = mcp_manager
         self.store = store
         self.workflow_service = workflow_service
+        self.agent_runtime = FlowentAgentRuntime(
+            chat_completion=chat_completion,
+            cwd=cwd,
+            mcp_manager=mcp_manager,
+            store=store,
+            workflow_service=workflow_service,
+        )
         self.active_response: WorkspaceResponse | None = None
         self.generation = 0
         self.active_compact_task: WorkspaceCompactTask | None = None
     def extra_tool_specs(self) -> list[Mapping[str, object]]:
-        return [
-            *workflow_tool_specs(),
-            *list(self.mcp_manager.tool_specs()),
-        ]
+        return self.agent_runtime.extra_tool_specs()
     def model_tool_specs(self) -> list[Mapping[str, object]]:
-        return [*tool_specs(), *self.extra_tool_specs()]
-    def workflow_tools(self) -> WorkflowAgentTools:
-        return WorkflowAgentTools(self.workflow_service)
-    async def run_extra_tool(
-        self,
-        workflow_tools: WorkflowAgentTools,
-        name: str,
-        arguments: dict[str, object],
-    ) -> ToolResult | None:
-        workflow_result = await workflow_tools.run_tool(name, arguments)
-        if workflow_result is not None:
-            return workflow_result
-        return await self.mcp_manager.run_tool(name, arguments)
+        return self.agent_runtime.model_tool_specs()
     def extra_tool_title(self, name: str) -> str | None:
-        return workflow_tool_title(name) or self.mcp_manager.tool_title(name)
+        return self.agent_runtime.extra_tool_title(name)
     def request_messages_for_content(
         self,
@@ -263,7 +246,6 @@ class WorkspaceRuntime:
         )
         next_messages = [*state.messages, user_message]
         self.store.save_messages(next_messages)
-        extra_tool_specs = self.extra_tool_specs()
         model_tool_specs = self.model_tool_specs()
         model_history: list[ChatMessage | Mapping[str, object]] = [
             *runtime_context_messages(self.cwd, state.settings.agent_prompt),
@@ -297,49 +279,11 @@ class WorkspaceRuntime:
         current_output_index = 0
         latest_usage_output_index: int | None = None
-        async def review_tool_approval(request: ApprovalReviewRequest):
-            return await review_approval_request(
-                connection,
-                request.model_copy(
-                    update={
-                        "transcript": approval_transcript(next_messages),
-                        "user_request": content,
-                    }
-                ),
-                completion=self.chat_completion,
-            )
-        async def tool_runner(
-            name: str,
-            arguments: dict[str, object],
-            context: ToolContext,
-        ):
-            return await run_tool_with_path_permissions(
-                name,
-                arguments,
-                context,
-                review_approval=review_tool_approval,
-                writable_paths=[
-                    Path(path.path) for path in self.store.read_writable_paths()
-                ],
-            )
-        workflow_tools = self.workflow_tools()
-        async def extra_tool_runner(
-            name: str, arguments: dict[str, object]
-        ) -> ToolResult | None:
-            return await self.run_extra_tool(workflow_tools, name, arguments)
-        async for event in run_agent_stream(
-            completion=self.chat_completion,
+        async for event in self.agent_runtime.stream(
+            approval_transcript=approval_transcript(next_messages),
             connection=connection,
-            cwd=self.cwd,
-            extra_tool_runner=extra_tool_runner,
-            extra_tool_specs=extra_tool_specs,
-            extra_tool_title=self.extra_tool_title,
             messages=request_messages,
-            tool_runner=tool_runner,
+            user_request=content,
         ):
             if event.event == "start":
                 event_id = event.data.get("id")
@@ -656,16 +600,37 @@ class WorkspaceRuntime:
             *base_request_messages,
             *model_visible_assistant_output_messages(trimmed_message),
         ]
-        response = self._start_response_from_messages(
-            content=previous_user_message.content,
-            initial_assistant_message=trimmed_message,
-            next_messages=next_messages,
-            output_start_index=assistant_retry_output_start_index(trimmed_message),
-            request_messages=request_messages,
-            state=state_before_assistant,
-            usage_request_messages=base_request_messages,
-            user_message=previous_user_message,
-        )
+        try:
+            response = self._start_response_from_messages(
+                content=previous_user_message.content,
+                initial_assistant_message=trimmed_message,
+                next_messages=next_messages,
+                output_start_index=assistant_retry_output_start_index(trimmed_message),
+                request_messages=request_messages,
+                state=state_before_assistant,
+                usage_request_messages=base_request_messages,
+                user_message=previous_user_message,
+            )
+        except HTTPException as error:
+            error_detail = str(error.detail or "")
+            assistant_output = AssistantOutputBuilder.from_message(trimmed_message)
+            assistant_output.append_error(
+                run_error_output_item(trimmed_message.id, error_detail).model_copy(
+                    update={"id": error_id}
+                )
+            )
+            failed_message = StoredMessage(
+                author="assistant",
+                content=assistant_output.content,
+                groups=assistant_output.groups,
+                id=trimmed_message.id,
+                status="failed",
+                thinking=assistant_output.thinking,
+                tools=list(assistant_output.tools.values()),
+                usage_info=self.store.read_usage_info(),
+            )
+            self.store.save_messages([*previous_messages, failed_message])
+            raise
         return next_messages, response
     def _start_response_from_messages(
@@ -770,7 +735,6 @@ class WorkspaceRuntime:
                 turn_usage_info: TokenUsageInfo | None = None
                 current_output_index = 0
                 latest_usage_output_index: int | None = None
-                extra_tool_specs = self.extra_tool_specs()
                 model_tool_specs = self.model_tool_specs()
                 if request_messages is None:
                     current_request_messages = self.request_messages_for_content(
@@ -853,33 +817,6 @@ class WorkspaceRuntime:
                     else current_request_messages
                 )
-                async def review_tool_approval(request: ApprovalReviewRequest):
-                    return await review_approval_request(
-                        connection,
-                        request.model_copy(
-                            update={
-                                "transcript": approval_transcript(next_messages),
-                                "user_request": content,
-                            }
-                        ),
-                        completion=self.chat_completion,
-                    )
-                async def tool_runner(
-                    name: str,
-                    arguments: dict[str, object],
-                    context: ToolContext,
-                ):
-                    return await run_tool_with_path_permissions(
-                        name,
-                        arguments,
-                        context,
-                        review_approval=review_tool_approval,
-                        writable_paths=[
-                            Path(path.path) for path in self.store.read_writable_paths()
-                        ],
-                    )
                 async def context_compactor(
                     conversation: Sequence[Mapping[str, object]],
                 ) -> AgentContextUpdate | None:
@@ -926,23 +863,12 @@ class WorkspaceRuntime:
                         },
                     )
-                workflow_tools = self.workflow_tools()
-                async def extra_tool_runner(
-                    name: str, arguments: dict[str, object]
-                ) -> ToolResult | None:
-                    return await self.run_extra_tool(workflow_tools, name, arguments)
-                async for event in run_agent_stream(
-                    completion=self.chat_completion,
+                async for event in self.agent_runtime.stream(
+                    approval_transcript=approval_transcript(next_messages),
                     connection=connection,
                     context_compactor=context_compactor,
-                    cwd=self.cwd,
-                    extra_tool_runner=extra_tool_runner,
-                    extra_tool_specs=extra_tool_specs,
-                    extra_tool_title=self.extra_tool_title,
                     messages=current_request_messages,
-                    tool_runner=tool_runner,
+                    user_request=content,
                 ):
                     if not is_current_generation() or response.discard_on_cancel:
                         raise asyncio.CancelledError

package/backend/uv.lock CHANGED Viewed

@@ -701,7 +701,7 @@ wheels = [
 [[package]]
 name = "flowent"
-version = "0.3.3"
+version = "0.3.4"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi", extra = ["standard"] },