From cf8d2adc44c8c1eb66343c83503462ed6114d501 Mon Sep 17 00:00:00 2001 From: Lightning Pixel Date: Sun, 4 Oct 2026 21:55:29 +0200 Subject: [PATCH 1/2] dump version 0.4.3 --- api/main.py | 2 +- package.json | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/api/main.py b/api/main.py index 20159f1c8..958ba2a02 100644 --- a/api/main.py +++ b/api/main.py @@ -36,7 +36,7 @@ def filter(self, record): app = FastAPI( title="Modly API", - version="0.4.2", + version="0.4.3", lifespan=lifespan, ) diff --git a/package.json b/package.json index a63727a24..8c3a985b6 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "modly", - "version": "0.4.2", + "version": "0.4.3", "description": "Local AI-powered 3D mesh generation from images", "main": "./out/main/index.js", "author": "Modly", From 16e497b20e3713a8843a43c9b745f501d808e152 Mon Sep 17 00:00:00 2001 From: Lightning Pixel Date: Tue, 20 Oct 2026 11:23:26 +0200 Subject: [PATCH 2/2] feat(agent): stream chat responses as typed SSE events agent_chat now returns a StreamingResponse emitting token, thinking, tool_start, tool_done and done events. ChatPanel consumes the stream so text appears progressively and tool calls show an in-progress state. Closes #300 --- api/routers/agent.py | 326 +++++++++++++++++--- api/tests/test_agent_streaming.py | 293 ++++++++++++++++++ package.json | 2 +- src/areas/generate/components/ChatPanel.tsx | 162 ++++++---- src/shared/utils/agentStream.test.ts | 57 ++++ src/shared/utils/agentStream.ts | 75 +++++ 6 files changed, 808 insertions(+), 107 deletions(-) create mode 100644 api/tests/test_agent_streaming.py create mode 100644 src/shared/utils/agentStream.test.ts create mode 100644 src/shared/utils/agentStream.ts diff --git a/api/routers/agent.py b/api/routers/agent.py index 3cf15d442..e2cb56efb 100644 --- a/api/routers/agent.py +++ b/api/routers/agent.py @@ -4,12 +4,12 @@ """ import asyncio import json -import re import uuid from typing import Optional import httpx from fastapi import APIRouter +from fastapi.responses import StreamingResponse from pydantic import BaseModel, Field from services import llm_server @@ -634,19 +634,6 @@ class AgentChatResponse(BaseModel): thinking: str | None = None -def _extract_thinking(msg: dict) -> tuple[str, str | None]: - """Return (clean_content, thinking_text). Handles llama-server's - reasoning_content field and inline tags.""" - content = msg.get("content") or "" - thinking = msg.get("reasoning_content") or None - if not thinking: - match = re.search(r"(.*?)", content, re.DOTALL) - if match: - thinking = match.group(1).strip() - content = (content[: match.start()] + content[match.end() :]).strip() - return content, thinking - - def _auth_headers(base_url: str, api_key: Optional[str]) -> dict: headers: dict[str, str] = {} if api_key: @@ -741,8 +728,198 @@ def _drop_images(messages: list[dict]) -> bool: return dropped -@router.post("/chat", response_model=AgentChatResponse) -async def agent_chat(request: AgentChatRequest): +class _ThinkSplitter: + """Route inline … text to the reasoning, the rest to the + answer, holding back a tag a chunk boundary has cut in two.""" + + _OPEN, _CLOSE = "", "" + + def __init__(self) -> None: + self._buffer = "" + self._inside = False + + def _held(self, *tags: str) -> int: + """Length of the buffer's tail that may be the start of a tag.""" + return max( + next((n for n in range(len(tag) - 1, 0, -1) if self._buffer.endswith(tag[:n])), 0) + for tag in tags + ) + + def _cut(self, index: int, tag: str, kind: str, parts: list) -> None: + if index: + parts.append((kind, self._buffer[:index])) + self._buffer = self._buffer[index + len(tag):] + + def feed(self, text: str) -> list[tuple[str, str]]: + self._buffer += text + parts: list[tuple[str, str]] = [] + while self._buffer: + close_at = self._buffer.find(self._CLOSE) + if self._inside: + if close_at >= 0: + self._cut(close_at, self._CLOSE, "thinking", parts) + self._inside = False + continue + keep = self._held(self._CLOSE) + kind = "thinking" + else: + open_at = self._buffer.find(self._OPEN) + if close_at >= 0 and (open_at < 0 or close_at < open_at): + # A chat template that opens in the prompt leaves the + # model only the closing tag: what came before it was reasoning. + self._cut(close_at, self._CLOSE, "thinking", parts) + continue + if open_at >= 0: + self._cut(open_at, self._OPEN, "token", parts) + self._inside = True + continue + keep = self._held(self._OPEN, self._CLOSE) + kind = "token" + if len(self._buffer) > keep: + parts.append((kind, self._buffer[: len(self._buffer) - keep])) + self._buffer = self._buffer[len(self._buffer) - keep:] + break + return parts + + def flush(self) -> list[tuple[str, str]]: + rest, self._buffer = self._buffer, "" + return [("thinking" if self._inside else "token", rest)] if rest else [] + + +class _Round: + """One LLM call of the tool loop, assembled from its streamed deltas.""" + + def __init__(self, answered_before: bool, thought_before: bool) -> None: + self.raw = "" # content as the model sent it, tags included + self.answer = "" + self.thinking = "" + self.tool_calls: dict[int, dict] = {} + self._splitter = _ThinkSplitter() + self._answered_before = answered_before + self._thought_before = thought_before + + def _text(self, kind: str, text: str) -> dict | None: + # Each round's text is stripped at its start, as the non-streamed + # answer was, and set apart from what earlier rounds already showed. + if kind == "token": + if not self.answer: + text = text.lstrip() + if not text: + return None + self.answer = text + return {"type": "token", "text": ("\n\n" if self._answered_before else "") + text} + self.answer += text + return {"type": "token", "text": text} + if not self.thinking: + text = text.lstrip() + if not text: + return None + self.thinking = text + return {"type": "thinking", "text": ("\n\n---\n\n" if self._thought_before else "") + text} + self.thinking += text + return {"type": "thinking", "text": text} + + def apply(self, delta: dict) -> list[dict]: + events = [] + # llama-server sends reasoning_content; Ollama and OpenRouter, reasoning. + reasoning = delta.get("reasoning_content") or delta.get("reasoning") + if isinstance(reasoning, str) and reasoning: + events.append(self._text("thinking", reasoning)) + content = delta.get("content") + if isinstance(content, str) and content: + self.raw += content + events.extend(self._text(kind, text) for kind, text in self._splitter.feed(content)) + for position, fragment in enumerate(delta.get("tool_calls") or []): + # Streamed tool calls arrive in fragments keyed by index: the id and + # name come first, the JSON arguments in pieces after them. + call = self.tool_calls.setdefault( + fragment.get("index", position), + {"id": "", "type": "function", "function": {"name": "", "arguments": ""}}, + ) + call["id"] = fragment.get("id") or call["id"] + function = fragment.get("function") or {} + call["function"]["name"] += function.get("name") or "" + arguments = function.get("arguments") + if isinstance(arguments, dict): + arguments = json.dumps(arguments) + call["function"]["arguments"] += arguments or "" + return [e for e in events if e] + + def finish(self) -> list[dict]: + return [e for e in (self._text(k, t) for k, t in self._splitter.flush()) if e] + + def calls(self) -> list[dict]: + calls = [self.tool_calls[i] for i in sorted(self.tool_calls)] + for call in calls: + # The tool result must answer the call's id; a few servers omit it. + call["id"] = call["id"] or f"call_{uuid.uuid4().hex[:8]}" + return calls + + +async def _read_round(response: httpx.Response, round_: _Round): + """Yield the answer and reasoning of one LLM call as they stream in.""" + if "text/event-stream" not in response.headers.get("content-type", ""): + # A server that ignored "stream": true answers in one JSON body. + message = json.loads(await response.aread())["choices"][0]["message"] + for event in round_.apply(message): + yield event + else: + async for line in response.aiter_lines(): + if not line.startswith("data:"): + continue + data = line[len("data:"):].strip() + if data == "[DONE]": + break + try: + choices = json.loads(data).get("choices") or [] + except ValueError: + continue + if choices: + for event in round_.apply(choices[0].get("delta") or {}): + yield event + for event in round_.finish(): + yield event + + +def _done(message: str, actions: list[ActionDone], thinking: list[str], error: bool = False) -> dict: + return { + "type": "done", + "message": message, + "actions": [a.model_dump() for a in actions], + "thinking": "\n\n---\n\n".join(thinking) if thinking else None, + # The message reports a failure rather than answering: the chat shows + # it after whatever text already streamed. + "error": error, + } + + +def _release_claimed(claim: asyncio.Future) -> None: + if not claim.cancelled() and claim.exception() is None: + claim.result().release() + + +async def _claim_slot(model: str, spec: dict): + """Hold a local LLM slot, without leaking it if the caller is cancelled. + + A streamed chat is cancelled when its client leaves, possibly while the + model is still loading. The loading thread can't be stopped and claims the + slot anyway; nobody would release it, and a held slot is never reaped. + """ + claim = asyncio.ensure_future(asyncio.to_thread(llama_pool.ensure, model, spec, True)) + try: + return await asyncio.shield(claim) + except asyncio.CancelledError: + claim.add_done_callback(_release_claimed) + raise + + +async def _chat_events(request: AgentChatRequest): + """Run the tool loop, yielding its events as they happen. + + token / thinking — answer and reasoning text, in pieces + tool_start / tool_done — around each tool call + done — always last: the final answer, every action and the full reasoning + """ messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT}] # Inject scene context so the LLM knows current state @@ -785,9 +962,10 @@ async def agent_chat(request: AgentChatRequest): spec = llm_server.resolve_model(request.model) # hold=True: the slot stays claimed for the whole loop, so neither the # idle reaper nor a model loading elsewhere can evict it mid-answer. - slot = await asyncio.to_thread(llama_pool.ensure, request.model, spec, True) + slot = await _claim_slot(request.model, spec) except Exception as e: - return AgentChatResponse(message=f"Could not start the local LLM: {e}") + yield _done(f"Could not start the local LLM: {e}", [], [], error=True) + return base_url = slot.base_url headers: dict = {} send_images = spec["vision"] @@ -796,7 +974,8 @@ async def agent_chat(request: AgentChatRequest): extra["chat_template_kwargs"] = {"enable_thinking": False} else: if not request.provider.base_url: - return AgentChatResponse(message="No provider URL configured. Set one in Settings → Agent.") + yield _done("No provider URL configured. Set one in Settings → Agent.", [], [], error=True) + return base_url = request.provider.base_url.rstrip("/") headers = _auth_headers(base_url, request.provider.api_key) @@ -805,52 +984,70 @@ async def agent_chat(request: AgentChatRequest): actions_done: list[ActionDone] = [] all_thinking: list[str] = [] - final: AgentChatResponse | None = None + final: str | None = None + error: str | None = None + answered = False try: async with httpx.AsyncClient(timeout=120.0) as client: - for _ in range(10): # max tool-call rounds - r = await client.post( - f"{base_url}/chat/completions", - headers=headers, - json={"model": request.model, "messages": messages, "tools": TOOLS, "stream": False, **extra}, - ) - # An external model's vision support is unknown up front, and a - # text-only one rejects image parts with a 400 that failed the - # whole turn. Retry once with the images described as omitted. - if r.status_code == 400 and request.provider.type != "local" and _drop_images(messages): - r = await client.post( + + async def post() -> httpx.Response: + return await client.send( + client.build_request( + "POST", f"{base_url}/chat/completions", headers=headers, - json={"model": request.model, "messages": messages, "tools": TOOLS, "stream": False, **extra}, - ) - - if r.status_code != 200: - return AgentChatResponse(message=f"LLM error ({r.status_code}): {_error_detail(r)}") + json={"model": request.model, "messages": messages, "tools": TOOLS, "stream": True, **extra}, + ), + stream=True, + ) - msg = r.json()["choices"][0]["message"] - tool_calls = msg.get("tool_calls") or [] - assistant: dict = {"role": "assistant", "content": msg.get("content") or ""} + for _ in range(10): # max tool-call rounds + round_ = _Round(answered, bool(all_thinking)) + r = await post() + try: + # An external model's vision support is unknown up front, and a + # text-only one rejects image parts with a 400 that failed the + # whole turn. Retry once with the images described as omitted. + if r.status_code == 400 and request.provider.type != "local" and _drop_images(messages): + await r.aclose() + r = await post() + + if r.status_code != 200: + await r.aread() + error = f"LLM error ({r.status_code}): {_error_detail(r)}" + break + + async for event in _read_round(r, round_): + yield event + finally: + await r.aclose() + + answered = answered or bool(round_.answer) + if round_.thinking: + all_thinking.append(round_.thinking) + tool_calls = round_.calls() + assistant: dict = {"role": "assistant", "content": round_.raw} if tool_calls: assistant["tool_calls"] = tool_calls messages.append(assistant) - clean_content, thinking_text = _extract_thinking(msg) - if thinking_text: - all_thinking.append(thinking_text) - if not tool_calls: - final = AgentChatResponse(message=clean_content, actions=actions_done) + final = round_.answer.strip() break for tc in tool_calls: fn = tc["function"] - result_text, payload = await execute_tool(fn["name"], _tool_arguments(fn.get("arguments")), request.context) + arguments = _tool_arguments(fn.get("arguments")) + yield {"type": "tool_start", "id": tc["id"], "tool": fn["name"], "arguments": arguments} + result_text, payload = await execute_tool(fn["name"], arguments, request.context) actions_done.append(ActionDone(tool=fn["name"], result=result_text, payload=payload)) - messages.append({"role": "tool", "tool_call_id": tc.get("id", ""), "content": result_text}) + yield {"type": "tool_done", "id": tc["id"], "tool": fn["name"], "result": result_text, "payload": payload} + messages.append({"role": "tool", "tool_call_id": tc["id"], "content": result_text}) except httpx.HTTPError as e: - return AgentChatResponse(message=f"Could not reach the LLM at {base_url}: {e}", actions=actions_done) + error = f"Could not reach the LLM at {base_url}: {e}" finally: + # Also runs when the client disconnects mid-answer. if slot is not None: slot.release() @@ -858,7 +1055,34 @@ async def agent_chat(request: AgentChatRequest): # still holding ours would keep the agent's own model on the GPU. await _unload_llm_after_workflow(request, actions_done) - if final is None: - final = AgentChatResponse(message="Reached maximum tool iterations.", actions=actions_done) - final.thinking = "\n\n---\n\n".join(all_thinking) if all_thinking else None - return final + if error is not None: + yield _done(error, actions_done, all_thinking, error=True) + elif final is None: + yield _done("Reached maximum tool iterations.", actions_done, all_thinking, error=True) + else: + yield _done(final, actions_done, all_thinking) + + +@router.post("/chat", response_model=AgentChatResponse) +async def agent_chat(request: AgentChatRequest): + """The whole turn at once, for callers that don't read a stream.""" + done: dict = {} + async for event in _chat_events(request): + if event["type"] == "done": + done = event + return AgentChatResponse(message=done["message"], actions=done["actions"], thinking=done["thinking"]) + + +@router.post("/chat/stream") +async def agent_chat_stream(request: AgentChatRequest): + """The same turn as Server-Sent Events, one JSON event per `data:` line.""" + + async def body(): + async for event in _chat_events(request): + yield f"data: {json.dumps(event)}\n\n" + + return StreamingResponse( + body(), + media_type="text/event-stream", + headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"}, + ) diff --git a/api/tests/test_agent_streaming.py b/api/tests/test_agent_streaming.py new file mode 100644 index 000000000..123e93c2c --- /dev/null +++ b/api/tests/test_agent_streaming.py @@ -0,0 +1,293 @@ +import asyncio +import json +import threading +import unittest +from unittest import mock + +import httpx + +import routers.agent as agent + + +def _sse(*deltas: dict) -> httpx.Response: + """A streamed /chat/completions answer, one chunk per delta.""" + lines = [f"data: {json.dumps({'choices': [{'delta': d}]})}\n\n" for d in deltas] + lines.append("data: [DONE]\n\n") + return httpx.Response( + 200, + headers={"content-type": "text/event-stream"}, + content="".join(lines).encode(), + ) + + +def _call(index: int, **fields) -> dict: + return {"tool_calls": [{"index": index, **fields}]} + + +_WORKFLOWS = {"workflows": [{"id": "wf1", "name": "My Workflow"}]} + + +class _Scripted: + """Patches httpx.AsyncClient to serve scripted responses in order, recording + every request body.""" + + def __init__(self, *responses: httpx.Response) -> None: + self._responses = list(responses) + self.bodies: list[dict] = [] + self._real = httpx.AsyncClient + + def _handler(self, request: httpx.Request) -> httpx.Response: + self.bodies.append(json.loads(request.content)) + return self._responses.pop(0) + + def __call__(self, *args, **kwargs): + kwargs["transport"] = httpx.MockTransport(self._handler) + return self._real(*args, **kwargs) + + +def _external(context=None) -> agent.AgentChatRequest: + return agent.AgentChatRequest( + messages=[agent.ChatMessage(role="user", content="hi")], + model="gpt-test", + provider=agent.ProviderConfig(type="external", base_url="https://llm.test/v1", api_key="k"), + context=context or {}, + ) + + +def _events(scripted: _Scripted, request: agent.AgentChatRequest) -> list[dict]: + async def collect(): + return [event async for event in agent._chat_events(request)] + + with mock.patch.object(agent.httpx, "AsyncClient", scripted): + return asyncio.run(collect()) + + +def _text(events: list[dict], kind: str) -> str: + return "".join(e["text"] for e in events if e["type"] == kind) + + +class ChatEventTests(unittest.TestCase): + def test_answer_streams_token_by_token_then_done(self) -> None: + scripted = _Scripted(_sse({"content": "Hel"}, {"content": "lo"}, {"content": " there"})) + + events = _events(scripted, _external()) + + self.assertEqual([e["type"] for e in events], ["token", "token", "token", "done"]) + self.assertEqual(_text(events, "token"), "Hello there") + self.assertEqual(events[-1]["message"], "Hello there") + self.assertFalse(events[-1]["error"]) + self.assertTrue(scripted.bodies[0]["stream"]) + + def test_reasoning_field_streams_as_thinking(self) -> None: + events = _events( + _Scripted(_sse({"reasoning_content": "Let me "}, {"reasoning_content": "think."}, {"content": "Hi"})), + _external(), + ) + + self.assertEqual(_text(events, "thinking"), "Let me think.") + self.assertEqual(_text(events, "token"), "Hi") + self.assertEqual(events[-1]["thinking"], "Let me think.") + + def test_inline_think_tags_cut_across_chunks_are_split_out(self) -> None: + events = _events( + _Scripted(_sse({"content": "plan\n\nHello "})), + _external(), + ) + + self.assertEqual(_text(events, "thinking"), "plan") + # A "<" that turns out not to open a tag is still part of the answer. + self.assertEqual(_text(events, "token"), "Hello ") + self.assertEqual(events[-1]["message"], "Hello ") + + def test_fragmented_tool_call_is_reassembled_and_reported_around_its_run(self) -> None: + scripted = _Scripted( + _sse( + {"content": "Starting it."}, + _call(0, id="call_1", type="function", function={"name": "run_workflow", "arguments": ""}), + _call(0, function={"arguments": '{"workflow_'}), + _call(0, function={"arguments": 'id": "wf1"}'}), + ), + _sse({"content": "Done."}), + ) + + events = _events(scripted, _external(_WORKFLOWS)) + + types = [e["type"] for e in events] + self.assertEqual(types, ["token", "tool_start", "tool_done", "token", "done"]) + start, finish = events[1], events[2] + self.assertEqual((start["id"], start["tool"], start["arguments"]), ("call_1", "run_workflow", {"workflow_id": "wf1"})) + self.assertEqual(finish["payload"]["type"], "run_workflow") + # Rounds are set apart in the streamed text; the final answer is the last one. + self.assertEqual(_text(events, "token"), "Starting it.\n\nDone.") + self.assertEqual(events[-1]["message"], "Done.") + self.assertEqual([a["tool"] for a in events[-1]["actions"]], ["run_workflow"]) + + replay = scripted.bodies[1]["messages"] + assistant = next(m for m in replay if m["role"] == "assistant") + self.assertEqual(assistant["tool_calls"][0]["function"]["arguments"], '{"workflow_id": "wf1"}') + self.assertEqual(replay[-1], {"role": "tool", "tool_call_id": "call_1", "content": finish["result"]}) + + def test_tool_call_without_an_id_still_gets_its_result_matched(self) -> None: + scripted = _Scripted( + _sse(_call(0, function={"name": "run_workflow", "arguments": '{"workflow_id": "wf1"}'})), + _sse({"content": "ok"}), + ) + + events = _events(scripted, _external(_WORKFLOWS)) + + call_id = events[0]["id"] + self.assertTrue(call_id) + tool_message = scripted.bodies[1]["messages"][-1] + self.assertEqual(tool_message["tool_call_id"], call_id) + + def test_reasoning_of_successive_rounds_is_separated(self) -> None: + scripted = _Scripted( + _sse({"reasoning_content": "first"}, _call(0, id="c", function={"name": "list_workflows", "arguments": "{}"})), + _sse({"reasoning_content": "second"}, {"content": "ok"}), + ) + + with mock.patch.object(agent, "execute_tool", mock.AsyncMock(return_value=("none", None))): + events = _events(scripted, _external()) + + self.assertEqual(_text(events, "thinking"), "first\n\n---\n\nsecond") + self.assertEqual(events[-1]["thinking"], "first\n\n---\n\nsecond") + + def test_provider_error_ends_with_an_error_done(self) -> None: + events = _events( + _Scripted(httpx.Response(401, json={"error": {"message": "Incorrect API key provided."}})), + _external(), + ) + + self.assertEqual(len(events), 1) + self.assertTrue(events[0]["error"]) + self.assertEqual(events[0]["message"], "LLM error (401): Incorrect API key provided.") + + def test_tool_loop_limit_is_reported_as_an_error(self) -> None: + rounds = [ + _sse(_call(0, id=f"c{i}", function={"name": "list_workflows", "arguments": "{}"})) + for i in range(10) + ] + with mock.patch.object(agent, "execute_tool", mock.AsyncMock(return_value=("none", None))): + events = _events(_Scripted(*rounds), _external()) + + self.assertTrue(events[-1]["error"]) + self.assertEqual(events[-1]["message"], "Reached maximum tool iterations.") + self.assertEqual(len(events[-1]["actions"]), 10) + + def test_local_slot_is_released_when_the_client_disconnects(self) -> None: + class Slot: + base_url = "http://127.0.0.1:8791/v1" + released = 0 + + def release(self) -> None: + self.released += 1 + + slot = Slot() + request = agent.AgentChatRequest( + messages=[agent.ChatMessage(role="user", content="hi")], model="qwen3-4b" + ) + + async def first_event_then_disconnect(): + stream = agent._chat_events(request) + first = await stream.__anext__() + await stream.aclose() + return first + + with mock.patch.object(agent.httpx, "AsyncClient", _Scripted(_sse({"content": "a"}, {"content": "b"}))), \ + mock.patch.object(agent.llm_server, "resolve_model", return_value={"vision": False}), \ + mock.patch.object(agent.llama_pool, "ensure", return_value=slot), \ + mock.patch.object(agent.llama_pool, "unload_all"): + first = asyncio.run(first_event_then_disconnect()) + + self.assertEqual(first, {"type": "token", "text": "a"}) + self.assertEqual(slot.released, 1) + + def test_slot_claimed_after_the_client_left_during_loading_is_released(self) -> None: + class Slot: + base_url = "http://127.0.0.1:8791/v1" + released = 0 + + def release(self) -> None: + self.released += 1 + + slot = Slot() + loading, loaded = threading.Event(), threading.Event() + + def ensure(*_args): + loading.set() + loaded.wait(5) + return slot + + request = agent.AgentChatRequest( + messages=[agent.ChatMessage(role="user", content="hi")], model="qwen3-4b" + ) + + async def leave_while_loading(): + turn = asyncio.ensure_future(agent._chat_events(request).__anext__()) + await asyncio.to_thread(loading.wait, 5) + turn.cancel() + with self.assertRaises(asyncio.CancelledError): + await turn + loaded.set() # the model finishes loading after the client left + for _ in range(200): + if slot.released: + break + await asyncio.sleep(0.01) + + with mock.patch.object(agent.llm_server, "resolve_model", return_value={"vision": False}), \ + mock.patch.object(agent.llama_pool, "ensure", ensure): + asyncio.run(leave_while_loading()) + + self.assertEqual(slot.released, 1) + + +class StreamRouteTests(unittest.TestCase): + def test_stream_route_sends_one_json_event_per_data_line(self) -> None: + async def read_body(): + response = await agent.agent_chat_stream(_external()) + self.assertEqual(response.media_type, "text/event-stream") + return "".join([chunk async for chunk in response.body_iterator]) + + with mock.patch.object(agent.httpx, "AsyncClient", _Scripted(_sse({"content": "Hi"}))): + body = asyncio.run(read_body()) + + blocks = [b for b in body.split("\n\n") if b] + self.assertTrue(all(b.startswith("data: ") for b in blocks)) + events = [json.loads(b[len("data: "):]) for b in blocks] + self.assertEqual([e["type"] for e in events], ["token", "done"]) + + def test_json_route_returns_the_same_turn_at_once(self) -> None: + scripted = _Scripted( + _sse(_call(0, id="call_1", function={"name": "run_workflow", "arguments": '{"workflow_id": "wf1"}'})), + _sse({"reasoning_content": "hm"}, {"content": "Running."}), + ) + with mock.patch.object(agent.httpx, "AsyncClient", scripted): + response = asyncio.run(agent.agent_chat(_external(_WORKFLOWS))) + + self.assertEqual(response.message, "Running.") + self.assertEqual(response.thinking, "hm") + self.assertEqual([a.tool for a in response.actions], ["run_workflow"]) + + +class ThinkSplitterTests(unittest.TestCase): + def test_partial_tag_is_held_until_it_resolves(self) -> None: + splitter = agent._ThinkSplitter() + + self.assertEqual(splitter.feed("a<"), [("token", "a")]) + self.assertEqual(splitter.feed("think>b"), [("thinking", "b")]) + self.assertEqual(splitter.feed(" None: + # The chat template opened in the prompt, so only its end streams. + splitter = agent._ThinkSplitter() + self.assertEqual(splitter.feed("plan\n\nAnswer"), [("thinking", "plan"), ("token", "\n\nAnswer")]) + + # Reasoning that streamed before the tag was already shown; the tag is not. + splitter = agent._ThinkSplitter() + parts = splitter.feed("planAnswer") + splitter.flush() + self.assertEqual(parts, [("token", "plan"), ("token", "Answer")]) + + +if __name__ == "__main__": + unittest.main() diff --git a/package.json b/package.json index a63727a24..e8da0f9d5 100644 --- a/package.json +++ b/package.json @@ -13,7 +13,7 @@ "prepare-resources": "node scripts/download-python-embed.js", "test": "npm run test:py && npm run test:node", "test:py": "node scripts/run-pytests.mjs", - "test:node": "node --test --experimental-strip-types --experimental-loader ./scripts/node-ts-extensionless-loader.mjs src/shared/types/assetLibrary.test.ts src/areas/generate/assetLibraryProjection.test.ts src/areas/generate/assetLibraryService.test.ts src/areas/generate/assetLibraryUi.test.ts src/areas/generate/orcaSlicerLink.test.ts electron/main/artifact-registry-service.test.ts electron/main/extension-path-guard.test.ts electron/preload/artifact-registry-preload.test.ts && node --test electron/main/*.test.mjs src/**/*.test.mjs", + "test:node": "node --test --experimental-strip-types --experimental-loader ./scripts/node-ts-extensionless-loader.mjs src/shared/types/assetLibrary.test.ts src/areas/generate/assetLibraryProjection.test.ts src/areas/generate/assetLibraryService.test.ts src/areas/generate/assetLibraryUi.test.ts src/areas/generate/orcaSlicerLink.test.ts src/shared/utils/agentStream.test.ts electron/main/artifact-registry-service.test.ts electron/main/extension-path-guard.test.ts electron/preload/artifact-registry-preload.test.ts && node --test electron/main/*.test.mjs src/**/*.test.mjs", "package": "cross-env CSC_IDENTITY_AUTO_DISCOVERY=false npm run build && npm run prepare-resources && electron-builder", "package:mac": "cross-env CSC_IDENTITY_AUTO_DISCOVERY=false npm run build && npm run prepare-resources && electron-builder --mac --arm64", "lint": "eslint ." diff --git a/src/areas/generate/components/ChatPanel.tsx b/src/areas/generate/components/ChatPanel.tsx index 053e780a9..d6db103e2 100644 --- a/src/areas/generate/components/ChatPanel.tsx +++ b/src/areas/generate/components/ChatPanel.tsx @@ -6,11 +6,13 @@ import { useWorkflowsStore } from '@shared/stores/workflowsStore' import { useExtensionsStore } from '@shared/stores/extensionsStore' import { useWorkflowRunStore } from '@areas/workflows/workflowRunStore' import { buildAllWorkflowExtensions } from '@areas/workflows/mockExtensions' +import { readAgentEvents } from '@shared/utils/agentStream' // ─── Types ──────────────────────────────────────────────────────────────────── import type { ThinkingMode } from '@shared/stores/agentStore' import type { Workflow } from '@shared/types/electron.d' +import type { AgentAction, AgentActionPayload } from '@shared/utils/agentStream' interface Message { id: string @@ -19,19 +21,12 @@ interface Message { thinking?: string imageDataUrls?: string[] actions?: ActionDone[] + streaming?: boolean } -interface ActionDone { - tool: string - result: string - payload?: { - type: string - url?: string - face_count?: number - workflow_id?: string - workflow_name?: string - workflow?: Omit - } | null +interface ActionDone extends AgentAction { + id?: string + running?: boolean } // ─── Constants ──────────────────────────────────────────────────────────────── @@ -86,15 +81,23 @@ const TOOL_LABELS: Record = { function ActionsCard({ actions, onUndo }: { actions: ActionDone[]; onUndo?: () => void }): JSX.Element { const [expanded, setExpanded] = useState(false) const meshActions = actions.filter((a) => a.payload?.type === 'mesh_update') - const canUndo = meshActions.length > 0 && !!onUndo + const running = actions.find((a) => a.running) + const canUndo = meshActions.length > 0 && !!onUndo && !running return (
{/* Header */}
- - {actions.length} action{actions.length > 1 ? 's' : ''} performed - + {running ? ( + + + Running {running.tool.replace(/_/g, ' ')}… + + ) : ( + + {actions.length} action{actions.length > 1 ? 's' : ''} performed + + )}
{canUndo && (