mycode-sdk 0.4.2__tar.gz → 0.5.0__tar.gz

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mycode-sdk
-Version: 0.4.2
+Version: 0.5.0
 Summary: Multi-turn tool-calling agent runtime for embedding the mycode agent loop.
 Project-URL: Homepage, https://github.com/legibet/mycode
 Project-URL: Repository, https://github.com/legibet/mycode
@@ -25,7 +25,7 @@ Description-Content-Type: text/markdown
 
 # mycode-sdk
 
-Lightweight Python SDK for the mycode multi-turn tool-calling agent. Import name: `mycode`.
+Lightweight Python SDK for building agents.
 
 ## Install
 
@@ -35,9 +35,7 @@ uv add mycode-sdk
 pip install mycode-sdk
 ```
 
-## Quick Start
-
-`Agent(...)` fills in sensible defaults: provider inferred from the model id, `session_id` generated, session log auto-persisted to `~/.mycode/sessions/<session_id>/`. By default no tools are registered — pick the built-ins you want or register your own via `@tool`.
+## Quick start
 
 ```python
 import asyncio
@@ -50,31 +48,43 @@ async def main() -> None:
         model="claude-sonnet-4-6",
         api_key="YOUR_API_KEY",
         cwd=".",
-        system="You are a concise coding assistant.",
         tools=[read_tool, bash_tool],
     )
 
     async for event in agent.achat("Read pyproject.toml and tell me the project name."):
         if event.type == "text":
-            print(event.data["delta"], end="")
+            print(event.data["delta"], end="", flush=True)
 
 
 asyncio.run(main())
 ```
 
-To resume a previous conversation, pass the same `session_id` (the agent loads its own history from disk).
+`Agent(...)` infers the provider from the model id. No tools are registered unless you pass `tools=[...]`, and nothing is persisted unless you pass `session_dir=`.
 
-## Built-in tools
+For a synchronous call, use `run()` — it collects the stream into a `RunResult`:
+
+```python
+result = agent.run("Read pyproject.toml and tell me the project name.")
+print(result.text)
+```
 
-Pick and combine the four bundled coding tools:
+Call `achat` or `run` again on the same `Agent` to continue the conversation — history accumulates in `agent.messages`.
+
+To persist across processes, pass `session_dir` as the root directory; each `session_id` becomes a subdirectory. Reconstruct with the same `(session_dir, session_id)` to resume.
+
+## Built-in tools
 
 ```python
 from mycode import read_tool, write_tool, edit_tool, bash_tool
 ```
 
-## Custom Tools
+Only `bash_tool` streams incremental output as `tool_output` events; the others return a single result.
+
+## Custom tools
+
+`@tool` wraps a sync or `async def` Python function as a `ToolSpec`. Parameter type hints become the JSON schema sent to the provider.
 
-`@tool` wraps a plain Python function (sync or async) as a `ToolSpec`. If the first parameter is annotated `ToolContext`, the context is injected; use `ctx.call("read", {...})` to invoke another registered tool.
+Annotate the first parameter as `ToolContext` to have the context injected. Use `ctx.read / ctx.write / ctx.edit / ctx.bash` to invoke the built-ins, or `ctx.call(name, args)` for any registered tool by name.
 
 ```python
 from mycode import Agent, ToolContext, read_tool, tool
@@ -84,8 +94,8 @@ from mycode import Agent, ToolContext, read_tool, tool
 def summarize_file(ctx: ToolContext, path: str) -> str:
     """Return the first line of a text file."""
 
-    result = ctx.call("read", {"path": path})
-    return result.model_text.splitlines()[0] if result.model_text else ""
+    result = ctx.read(path)
+    return result.output.splitlines()[0] if result.output else ""
 
 
 agent = Agent(
@@ -96,19 +106,6 @@ agent = Agent(
 )
 ```
 
-Type hints drive the JSON schema. Unknown types raise; missing docstrings raise. `async def` tools are run via `asyncio.run` on the executor's worker thread.
+A bare `str` return becomes the tool `output`; any other JSON-serializable value is dumped to JSON. For finer control, return a `ToolExecutionResult` to set `output`, `content` (multimodal blocks such as images), `metadata` (structured UI data), and `is_error` independently.
 
-## Disabling auto-persistence
-
-Point `session_dir` (or the implied `SessionStore` data dir) at a temporary directory if you need an ephemeral session:
-
-```python
-import tempfile
-from pathlib import Path
-
-agent = Agent(
-    model="claude-sonnet-4-6",
-    cwd=".",
-    session_dir=Path(tempfile.mkdtemp()) / "scratch",
-)
-```
+See [docs/sdk.md](../docs/sdk.md) for the event stream, cancellation, session rules, and the full `Agent` / `@tool` reference.

mycode_sdk-0.5.0/README.md

@@ -0,0 +1,86 @@
+# mycode-sdk
+
+Lightweight Python SDK for building agents.
+
+## Install
+
+```bash
+uv add mycode-sdk
+# or
+pip install mycode-sdk
+```
+
+## Quick start
+
+```python
+import asyncio
+
+from mycode import Agent, bash_tool, read_tool
+
+
+async def main() -> None:
+    agent = Agent(
+        model="claude-sonnet-4-6",
+        api_key="YOUR_API_KEY",
+        cwd=".",
+        tools=[read_tool, bash_tool],
+    )
+
+    async for event in agent.achat("Read pyproject.toml and tell me the project name."):
+        if event.type == "text":
+            print(event.data["delta"], end="", flush=True)
+
+
+asyncio.run(main())
+```
+
+`Agent(...)` infers the provider from the model id. No tools are registered unless you pass `tools=[...]`, and nothing is persisted unless you pass `session_dir=`.
+
+For a synchronous call, use `run()` — it collects the stream into a `RunResult`:
+
+```python
+result = agent.run("Read pyproject.toml and tell me the project name.")
+print(result.text)
+```
+
+Call `achat` or `run` again on the same `Agent` to continue the conversation — history accumulates in `agent.messages`.
+
+To persist across processes, pass `session_dir` as the root directory; each `session_id` becomes a subdirectory. Reconstruct with the same `(session_dir, session_id)` to resume.
+
+## Built-in tools
+
+```python
+from mycode import read_tool, write_tool, edit_tool, bash_tool
+```
+
+Only `bash_tool` streams incremental output as `tool_output` events; the others return a single result.
+
+## Custom tools
+
+`@tool` wraps a sync or `async def` Python function as a `ToolSpec`. Parameter type hints become the JSON schema sent to the provider.
+
+Annotate the first parameter as `ToolContext` to have the context injected. Use `ctx.read / ctx.write / ctx.edit / ctx.bash` to invoke the built-ins, or `ctx.call(name, args)` for any registered tool by name.
+
+```python
+from mycode import Agent, ToolContext, read_tool, tool
+
+
+@tool
+def summarize_file(ctx: ToolContext, path: str) -> str:
+    """Return the first line of a text file."""
+
+    result = ctx.read(path)
+    return result.output.splitlines()[0] if result.output else ""
+
+
+agent = Agent(
+    model="claude-sonnet-4-6",
+    api_key="YOUR_API_KEY",
+    cwd=".",
+    tools=[read_tool, summarize_file],
+)
+```
+
+A bare `str` return becomes the tool `output`; any other JSON-serializable value is dumped to JSON. For finer control, return a `ToolExecutionResult` to set `output`, `content` (multimodal blocks such as images), `metadata` (structured UI data), and `is_error` independently.
+
+See [docs/sdk.md](../docs/sdk.md) for the event stream, cancellation, session rules, and the full `Agent` / `@tool` reference.

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "mycode-sdk"
-version = "0.4.2"
+version = "0.5.0"
 description = "Multi-turn tool-calling agent runtime for embedding the mycode agent loop."
 readme = "README.md"
 requires-python = ">=3.12"

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/__init__.py

@@ -7,7 +7,7 @@ runtime ships four built-in coding tools (``read``, ``write``, ``edit``,
 silently exposing file system and shell access.
 """
 
-from mycode.agent import Agent, Event, PersistCallback
+from mycode.agent import Agent, Event, PersistCallback, RunResult
 from mycode.messages import (
     ContentBlock,
     ConversationMessage,
@@ -47,6 +47,7 @@ __all__ = [
     "DEFAULT_TOOL_SPECS",
     "Event",
     "PersistCallback",
+    "RunResult",
     "SessionStore",
     "ToolContext",
     "ToolExecutionResult",

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/agent.py

@@ -1,14 +1,15 @@
 """Multi-turn agent loop.
 
 :class:`Agent` drives one conversation. Each call to :meth:`Agent.achat`
-runs one user turn and appends every emitted message to the on-disk
-session log.
+runs one user turn; when a ``session_dir`` is configured, every emitted
+message is appended to the on-disk session log.
 """
 
 from __future__ import annotations
 
 import asyncio
 import logging
+import tempfile
 from collections.abc import AsyncIterator, Awaitable, Callable, Sequence
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -31,10 +32,9 @@ from mycode.session import (
     SessionStore,
     apply_compact,
     build_compact_event,
-    resolve_sessions_dir,
     should_compact,
 )
-from mycode.tools import ToolExecutionResult, ToolExecutor, ToolSpec
+from mycode.tools import ToolContext, ToolExecutionResult, ToolExecutor, ToolSpec
 
 logger = logging.getLogger(__name__)
 
@@ -49,6 +49,15 @@ class Event:
     data: dict[str, Any] = field(default_factory=dict)
 
 
+@dataclass
+class RunResult:
+    """Collected result returned by :meth:`Agent.run`."""
+
+    text: str = ""
+    events: list[Event] = field(default_factory=list)
+    error: str | None = None
+
+
 class Agent:
     """Multi-turn tool-calling agent runtime."""
 
@@ -58,8 +67,8 @@ class Agent:
         model: str,
         cwd: str,
         provider: str | None = None,
-        session_id: str | None = None,
         session_dir: Path | None = None,
+        session_id: str | None = None,
         api_key: str | None = None,
         api_base: str | None = None,
         messages: list[ConversationMessage] | None = None,
@@ -72,7 +81,7 @@ class Agent:
         supports_image_input: bool | None = None,
         supports_pdf_input: bool | None = None,
         system: str = "",
-        tools: ToolExecutor | Sequence[ToolSpec] | None = None,
+        tools: Sequence[ToolSpec] = (),
     ):
         self.model = model
         if provider is None:
@@ -83,10 +92,13 @@ class Agent:
         self.provider = provider
 
         self.cwd = str(Path(cwd).resolve(strict=False))
-        # If only ``session_dir`` is supplied, derive the id from its directory name.
-        self.session_id = (session_id or "").strip() or (session_dir.name if session_dir is not None else uuid4().hex)
-        self.session_dir = session_dir if session_dir is not None else resolve_sessions_dir() / self.session_id
-        self._store = SessionStore(data_dir=self.session_dir.parent)
+
+        # Persistence is opt-in: a store is only created when ``session_dir``
+        # is supplied. ``session_id`` is always populated (uuid when absent)
+        # so Events can carry a stable runtime tag even in memory-only mode.
+        self.session_dir = session_dir
+        self.session_id = (session_id or "").strip() or uuid4().hex
+        self._store: SessionStore | None = SessionStore(data_dir=session_dir) if session_dir is not None else None
 
         self.api_key = api_key
         self.api_base = api_base
@@ -98,20 +110,38 @@ class Agent:
         self._cancel_event = asyncio.Event()
         self._provider_event_task: asyncio.Future[ProviderStreamEvent] | None = None
 
+        # History resolution:
+        # - messages is None → auto-resume from disk if the session exists
+        # - messages is [] or [...] → use as-is; refuse if it would overwrite disk
         if messages is None:
-            data = self._store.load_session_sync(self.session_id)
-            messages = list(data["messages"]) if data is not None else []
+            if self._store is not None:
+                data = self._store.load_session_sync(self.session_id)
+                messages = list(data["messages"]) if data is not None else []
+            else:
+                messages = []
+        elif self._store is not None and self._store.session_exists(self.session_id):
+            msg = (
+                f"session {self.session_id!r} already exists on disk; "
+                "pass messages=None to resume or choose a different session_id"
+            )
+            raise ValueError(msg)
         self.messages: list[ConversationMessage] = list(messages)
 
-        if isinstance(tools, ToolExecutor):
-            self.tools = tools
+        # Tool runtime: one executor per agent. ``tool_output_dir`` is where
+        # tools can drop artifacts — defaults to a session-adjacent directory
+        # so logs (e.g. bash spill files) live next to the session JSONL.
+        # When no session is configured, use a tempdir scoped to session_id.
+        if session_dir is not None:
+            tool_output_dir = session_dir / self.session_id / "tool-output"
         else:
-            self.tools = ToolExecutor(
-                cwd=self.cwd,
-                session_dir=self.session_dir,
-                tools=list(tools) if tools is not None else [],
-                supports_image_input=False,
-            )
+            tool_output_dir = Path(tempfile.gettempdir()) / "mycode" / self.session_id / "tool-output"
+        self.tools = ToolExecutor(tools)
+        self.tool_ctx = ToolContext(
+            executor=self.tools,
+            cwd=self.cwd,
+            tool_output_dir=tool_output_dir,
+            supports_image_input=False,
+        )
 
         self.refresh_capabilities(
             max_tokens=max_tokens,
@@ -151,7 +181,7 @@ class Agent:
         self.supports_reasoning: bool | None = meta.supports_reasoning
         self.supports_image_input: bool = bool(meta.supports_image_input)
         self.supports_pdf_input: bool = bool(meta.supports_pdf_input)
-        self.tools.supports_image_input = self.supports_image_input
+        self.tool_ctx.supports_image_input = self.supports_image_input
 
     def cancel(self) -> None:
         """Request cancellation of the in-flight turn."""
@@ -183,11 +213,7 @@ class Agent:
         if self._cancel_event.is_set():
             yield self._tool_done_event(
                 tool_id,
-                ToolExecutionResult(
-                    model_text="error: cancelled",
-                    display_text="Cancelled",
-                    is_error=True,
-                ),
+                ToolExecutionResult(output="error: cancelled", is_error=True),
             )
             return
 
@@ -195,11 +221,7 @@ class Agent:
         if spec is None:
             yield self._tool_done_event(
                 tool_id,
-                ToolExecutionResult(
-                    model_text=f"error: unknown tool: {name}",
-                    display_text=f"Unknown tool: {name}",
-                    is_error=True,
-                ),
+                ToolExecutionResult(output=f"error: unknown tool: {name}", is_error=True),
             )
             return
 
@@ -209,13 +231,10 @@ class Agent:
             return
 
         try:
-            result = await asyncio.to_thread(self.tools.execute, name, args)
+            ctx = self._ctx_for_call(tool_id)
+            result = await asyncio.to_thread(self.tools.execute, name, args, ctx)
         except Exception as exc:  # pragma: no cover - defensive
-            result = ToolExecutionResult(
-                model_text=f"error: {exc}",
-                display_text=str(exc),
-                is_error=True,
-            )
+            result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
 
         yield self._tool_done_event(tool_id, result)
 
@@ -234,15 +253,11 @@ class Agent:
         def on_output(line: str) -> None:
             loop.call_soon_threadsafe(output_queue.put_nowait, line)
 
+        ctx = self._ctx_for_call(tool_id, emit=on_output)
+
         async def run_in_thread() -> ToolExecutionResult:
             try:
-                return await asyncio.to_thread(
-                    self.tools.execute,
-                    name,
-                    args,
-                    tool_call_id=tool_id,
-                    on_output=on_output,
-                )
+                return await asyncio.to_thread(self.tools.execute, name, args, ctx)
             finally:
                 loop.call_soon_threadsafe(output_queue.put_nowait, None)
 
@@ -271,31 +286,41 @@ class Agent:
                 await task
             except Exception:
                 pass
-            result = ToolExecutionResult(
-                model_text="error: cancelled",
-                display_text="Cancelled",
-                is_error=True,
-            )
+            result = ToolExecutionResult(output="error: cancelled", is_error=True)
         else:
             try:
                 result = await task
             except Exception as exc:  # pragma: no cover - defensive
-                result = ToolExecutionResult(
-                    model_text=f"error: {exc}",
-                    display_text=str(exc),
-                    is_error=True,
-                )
+                result = ToolExecutionResult(output=f"error: {exc}", is_error=True)
 
         yield self._tool_done_event(tool_id, result)
 
+    def _ctx_for_call(
+        self,
+        tool_id: str,
+        *,
+        emit: Callable[[str], None] | None = None,
+    ) -> ToolContext:
+        """Build a per-call ToolContext from the base context."""
+
+        return ToolContext(
+            executor=self.tools,
+            cwd=self.tool_ctx.cwd,
+            tool_output_dir=self.tool_ctx.tool_output_dir,
+            supports_image_input=self.tool_ctx.supports_image_input,
+            tool_call_id=tool_id,
+            emit=emit,
+        )
+
     @staticmethod
     def _tool_done_event(tool_id: str, result: ToolExecutionResult) -> Event:
         data: dict[str, Any] = {
             "tool_use_id": tool_id,
-            "model_text": result.model_text,
-            "display_text": result.display_text,
+            "output": result.output,
             "is_error": result.is_error,
         }
+        if result.metadata:
+            data["metadata"] = result.metadata
         if result.content:
             data["content"] = result.content
         return Event("tool_done", data)
@@ -337,7 +362,7 @@ class Agent:
                     pass
 
     # ------------------------------------------------------------------
-    # Public entry point
+    # Public entry points
     # ------------------------------------------------------------------
 
     async def achat(
@@ -352,27 +377,26 @@ class Agent:
         requests tools, the agent runs them locally, appends one user-side
         tool_result message, and continues until the assistant stops using tools.
 
-        Every emitted message is appended to the session log. ``on_persist`` is
-        an optional hook fired *before* that append, useful for staging related
-        side effects (the web server uses it to land a rewind marker first).
+        When a ``session_dir`` is configured, every emitted message is appended
+        to the on-disk session log. ``on_persist`` fires *before* that append
+        regardless of whether a store is configured, so callers can plug in a
+        custom backend or stage related records (the web server uses it to
+        land a rewind marker first).
         """
 
         async def persist(message: ConversationMessage) -> None:
             if on_persist is not None:
                 await on_persist(message)
-            await self._store.append_message(
-                self.session_id,
-                message,
-                provider=self.provider,
-                model=self.model,
-                cwd=self.cwd,
-                api_base=self.api_base,
-            )
+            if self._store is None:
+                return
+            if not self._store.session_exists(self.session_id):
+                await self._store.create_session(self.session_id, cwd=self.cwd)
+            await self._store.append_message(self.session_id, message)
 
         self._cancel_event.clear()
         supports_image_input = self.supports_image_input
         supports_pdf_input = self.supports_pdf_input
-        self.tools.supports_image_input = supports_image_input
+        self.tool_ctx.supports_image_input = supports_image_input
 
         if isinstance(user_input, str):
             user_message = user_text_message(user_input)
@@ -491,19 +515,20 @@ class Agent:
                         continue
 
                     d = event.data
-                    model_text = str(d.get("model_text") or "")
+                    output = str(d.get("output") or "")
+                    metadata = d.get("metadata") if isinstance(d.get("metadata"), dict) else None
                     content = d.get("content")
                     tool_results.append(
                         tool_result_block(
                             tool_use_id=str(d.get("tool_use_id") or ""),
-                            model_text=model_text,
-                            display_text=str(d.get("display_text") or ""),
+                            output=output,
+                            metadata=metadata,
                             is_error=bool(d.get("is_error")),
                             content=content if isinstance(content, list) else None,
                         )
                     )
 
-                    if model_text == "error: cancelled" and self._cancel_event.is_set():
+                    if output == "error: cancelled" and self._cancel_event.is_set():
                         tool_result_message = build_message("user", tool_results)
                         self.messages.append(tool_result_message)
                         await persist(tool_result_message)
@@ -524,6 +549,33 @@ class Agent:
             async for event in self._compact_if_needed(adapter, persist):
                 yield event
 
+    def run(
+        self,
+        user_input: str | ConversationMessage,
+        *,
+        on_persist: PersistCallback | None = None,
+    ) -> RunResult:
+        """Run one user turn synchronously and collect the streamed result."""
+
+        try:
+            asyncio.get_running_loop()
+        except RuntimeError:
+            pass
+        else:
+            raise RuntimeError("Agent.run() cannot run inside an active event loop; use Agent.achat() instead")
+
+        async def collect() -> RunResult:
+            result = RunResult()
+            async for event in self.achat(user_input, on_persist=on_persist):
+                result.events.append(event)
+                if event.type == "text":
+                    result.text += str(event.data.get("delta") or "")
+                elif event.type == "error" and result.error is None:
+                    result.error = str(event.data.get("message") or "")
+            return result
+
+        return asyncio.run(collect())
+
     # ------------------------------------------------------------------
     # Context compaction
     # ------------------------------------------------------------------

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/messages.py

@@ -92,25 +92,28 @@ def tool_use_block(
 def tool_result_block(
     *,
     tool_use_id: str,
-    model_text: str,
-    display_text: str,
+    output: str,
+    metadata: dict[str, Any] | None = None,
     is_error: bool = False,
     content: list[ContentBlock] | None = None,
     meta: dict[str, Any] | None = None,
 ) -> ContentBlock:
     """Build a tool-result block.
 
-    `model_text` is replayed back to providers on later turns.
-    `display_text` is the user-facing text shown by CLI and web UI.
+    `output` is replayed back to providers on later turns.
+    `content` carries multimodal blocks (e.g. images) that providers should
+    replay alongside the text. `metadata` is an optional structured payload
+    for UI consumption (e.g. edit diff line numbers).
     """
 
     block: ContentBlock = {
         "type": "tool_result",
         "tool_use_id": tool_use_id,
-        "model_text": model_text,
-        "display_text": display_text,
+        "output": output,
         "is_error": is_error,
     }
+    if metadata:
+        block["metadata"] = dict(metadata)
     if content:
         block["content"] = [dict(item) for item in content]
     if meta:

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/models_catalog.json

@@ -901,13 +901,6 @@
       "supports_pdf_input": false,
       "supports_reasoning": false
     },
-    "codex-mini-latest": {
-      "context_window": 200000,
-      "max_output_tokens": 100000,
-      "supports_image_input": false,
-      "supports_pdf_input": false,
-      "supports_reasoning": true
-    },
     "gpt-3.5-turbo": {
       "context_window": 16385,
       "max_output_tokens": 4096,

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/providers/anthropic_like.py

@@ -300,7 +300,7 @@ class AnthropicLikeAdapter(ProviderAdapter):
             return {
                 "type": "tool_result",
                 "tool_use_id": block.get("tool_use_id"),
-                "content": content_blocks or str(block.get("model_text") or ""),
+                "content": content_blocks or str(block.get("output") or ""),
                 "is_error": bool(block.get("is_error")),
             }
 

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/providers/base.py

@@ -338,8 +338,7 @@ def _interrupted_tool_result_message(tool_use_ids: list[str]) -> ConversationMes
         [
             tool_result_block(
                 tool_use_id=tool_use_id,
-                model_text="error: tool call was interrupted",
-                display_text="Tool call was interrupted",
+                output="error: tool call was interrupted",
                 is_error=True,
             )
             for tool_use_id in tool_use_ids
@@ -384,4 +383,4 @@ def tool_result_content_blocks(block: dict[str, Any]) -> list[dict[str, Any]]:
         structured = [dict(item) for item in raw_content if isinstance(item, dict)]
         if structured:
             return structured
-    return [text_block(str(block.get("model_text") or ""))]
+    return [text_block(str(block.get("output") or ""))]

{mycode_sdk-0.4.2 → mycode_sdk-0.5.0}/src/mycode/providers/gemini.py

@@ -198,7 +198,7 @@ class GoogleGeminiAdapter(ProviderAdapter):
                     continue
 
                 tool_id = str(block.get("tool_use_id") or "")
-                response: dict[str, Any] = {"result": str(block.get("model_text") or "")}
+                response: dict[str, Any] = {"result": str(block.get("output") or "")}
                 if block.get("is_error"):
                     response["is_error"] = True