agentseek-api 0.2.0__tar.gz → 0.2.1__tar.gz

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 Notable changes to AgentSeek API are documented in this file.
 
+## 0.2.1 - 2026-07-14
+
+### Fixed
+
+- Preserved empty JSON arrays in Redis thread-stream events by avoiding a Lua
+  cjson decode/encode round trip, while keeping generated envelope fields
+  authoritative.
+- Mirrored completed tool, human, and system messages to `messages-tuple` when
+  requested so LangGraph SDK clients receive tool results before final-answer
+  streaming completes.
+
+### Upgrade notes
+
+- No schema or configuration migration is required from 0.2.0.
+
 ## 0.2.0 - 2026-07-12
 
 ### Highlights

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentseek-api
-Version: 0.2.0
+Version: 0.2.1
 Summary: AgentSeek API core runtime with OceanBase checkpoints.
 License-File: LICENSE
 Requires-Python: >=3.12
@@ -216,7 +216,7 @@ When the server starts it prints the banner and local URLs:
 ╠═╣│ ┬├┤ │││ │ ╚═╗├┤ ├┤ ├┴┐
 ╩ ╩└─┘└─┘┘└┘ ┴ ╚═╝└─┘└─┘┴ ┴
 
-     AgentSeek v0.2.0
+     AgentSeek v0.2.1
 
 - 🚀 API: http://localhost:2024
 - 📚 Docs: http://localhost:2024/docs

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/README.md

@@ -185,7 +185,7 @@ When the server starts it prints the banner and local URLs:
 ╠═╣│ ┬├┤ │││ │ ╚═╗├┤ ├┤ ├┴┐
 ╩ ╩└─┘└─┘┘└┘ ┴ ╚═╝└─┘└─┘┴ ┴
 
-     AgentSeek v0.2.0
+     AgentSeek v0.2.1
 
 - 🚀 API: http://localhost:2024
 - 📚 Docs: http://localhost:2024/docs

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/README.zh-CN.md

@@ -181,7 +181,7 @@ uv run agentseek-api dev --config ./langgraph.json
 ╠═╣│ ┬├┤ │││ │ ╚═╗├┤ ├┤ ├┴┐
 ╩ ╩└─┘└─┘┘└┘ ┴ ╚═╝└─┘└─┘┴ ┴
 
-     AgentSeek v0.2.0
+     AgentSeek v0.2.1
 
 - 🚀 API: http://localhost:2024
 - 📚 Docs: http://localhost:2024/docs

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "agentseek-api"
-version = "0.2.0"
+version = "0.2.1"
 description = "AgentSeek API core runtime with OceanBase checkpoints."
 readme = "README.md"
 requires-python = ">=3.12"

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/scripts/test-redis-runtime.sh

@@ -9,6 +9,7 @@ CONFIG_PATH="${CONFIG_PATH:-examples/docker_ci_auth/manifest.json}"
 NETWORK_NAME="${NETWORK_NAME:-agentseek-redis-runtime}"
 BACKEND_CONTAINER="${BACKEND_CONTAINER:-agentseek-redis-backend}"
 REDIS_CONTAINER="${REDIS_CONTAINER:-agentseek-redis}"
+REDIS_HOST_PORT="${REDIS_HOST_PORT:-6391}"
 API_CONTAINER="${API_CONTAINER:-agentseek-redis-api}"
 WORKER_CONTAINER="${WORKER_CONTAINER:-agentseek-redis-worker}"
 API_PORT="${API_PORT:-8126}"
@@ -113,6 +114,21 @@ PY
   fi
 }
 
+wait_for_redis() {
+  local attempt
+
+  for ((attempt = 1; attempt <= 30; attempt++)); do
+    if docker exec "$REDIS_CONTAINER" redis-cli ping >/dev/null 2>&1; then
+      return 0
+    fi
+    sleep 1
+  done
+
+  echo "Redis did not become ready" >&2
+  print_logs
+  return 1
+}
+
 ensure_database_exists() {
   uv run python - <<'PY'
 import os
@@ -252,8 +268,17 @@ docker rm -f "$REDIS_CONTAINER" >/dev/null 2>&1 || true
 docker run -d \
   --name "$REDIS_CONTAINER" \
   --network "$NETWORK_NAME" \
+  -p "127.0.0.1:${REDIS_HOST_PORT}:6379" \
   redis:7-alpine >/dev/null
 
+wait_for_redis
+
+if ! AGENTSEEK_TEST_REDIS_URL="redis://127.0.0.1:${REDIS_HOST_PORT}/0" \
+  uv run pytest tests/integration/test_live_redis_stream_persistence.py -q; then
+  print_logs
+  exit 1
+fi
+
 wait_for_backend
 ensure_database_exists
 

agentseek_api-0.2.1/src/agentseek_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/src/agentseek_api/services/run_executor.py

@@ -952,6 +952,22 @@ async def execute_run(
                                 namespace=protocol_namespace,
                                 run_id=run_id,
                             )
+                            # LangGraph SDK 1.x useStream subscribes to
+                            # messages-tuple, not messages/complete. Mirror the
+                            # completed non-AI message onto that requested
+                            # channel so ToolMessage resolves the pending tool
+                            # call while the run is still streaming.
+                            if _want_messages_tuple:
+                                event_metadata = (
+                                    _normalize_stream_value(stream_event.get("metadata", {})) or {}
+                                )
+                                await apublish_messages_tuple(
+                                    thread_id,
+                                    chunk=msg_dump,
+                                    metadata=event_metadata,
+                                    namespace=protocol_namespace,
+                                    run_id=run_id,
+                                )
                     continue
                 if _want_messages_tuple:
                     chunk_dump = _normalize_stream_value(message)

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/src/agentseek_api/services/stream_persistence.py

@@ -17,6 +17,7 @@ _RUN_STREAM_SEQ_KEY_PREFIX = "agentseek:runs:stream-seq"
 _THREAD_STREAM_SEQ_KEY_PREFIX = "agentseek:threads:stream-seq"
 _RUN_STREAM_KEY_PREFIX = "agentseek:runs:stream"
 _THREAD_STREAM_KEY_PREFIX = "agentseek:threads:stream"
+_THREAD_STREAM_ENVELOPE_FIELDS = frozenset({"type", "event_id", "seq"})
 _redis_client: Redis | None = None
 logger = logging.getLogger(__name__)
 
@@ -24,11 +25,23 @@ _APPEND_REDIS_STREAM_EVENT_SCRIPT = """
 local seq = redis.call('INCR', KEYS[1])
 local payload = ARGV[1]
 if ARGV[4] ~= '' then
-  local event = cjson.decode(payload)
-  event['type'] = 'event'
-  event['event_id'] = ARGV[4] .. ':' .. tostring(seq)
-  event['seq'] = seq
-  payload = cjson.encode(event)
+  -- Inject type/event_id/seq WITHOUT a cjson decode/encode round-trip.
+  -- Redis' bundled lua-cjson cannot distinguish an empty array from an empty
+  -- object, so cjson.encode(cjson.decode('{"tool_calls":[]}')) returns
+  -- '{"tool_calls":{}}'. That silently corrupts every streamed message
+  -- (tool_calls / invalid_tool_calls become {}), and langgraph-sdk's
+  -- convertToChunk() then throws on `{}.map`, so the client cannot concat
+  -- message chunks by id and each token replaces the previous one instead of
+  -- accumulating. Splice the header in as a string to keep the original
+  -- payload (and its empty arrays) byte-for-byte intact.
+  local rest = string.sub(payload, 2)
+  local event_id = cjson.encode(ARGV[4] .. ':' .. tostring(seq))
+  local head = '{"type":"event","event_id":' .. event_id .. ',"seq":' .. tostring(seq)
+  if rest == '}' then
+    payload = head .. '}'
+  else
+    payload = head .. ',' .. rest
+  end
 end
 redis.call('XADD', KEYS[2], 'MAXLEN', '~', ARGV[2], tostring(seq) .. '-0', 'payload', payload)
 redis.call('EXPIRE', KEYS[2], ARGV[3])
@@ -70,6 +83,8 @@ async def _append_redis_stream_event_atomic(
     payload: dict[str, Any],
     event_prefix: str = "",
 ) -> tuple[int, dict[str, Any]]:
+    if event_prefix:
+        payload = {key: value for key, value in payload.items() if key not in _THREAD_STREAM_ENVELOPE_FIELDS}
     result = await _get_redis_client().eval(
         _APPEND_REDIS_STREAM_EVENT_SCRIPT,
         2,

agentseek_api-0.2.1/tests/integration/test_live_redis_stream_persistence.py

@@ -0,0 +1,75 @@
+import json
+import os
+from uuid import uuid4
+
+import pytest
+from redis.asyncio import from_url
+
+from agentseek_api.services import stream_persistence as stream_module
+
+
+_TEST_REDIS_URL = os.getenv("AGENTSEEK_TEST_REDIS_URL")
+pytestmark = pytest.mark.skipif(
+    not _TEST_REDIS_URL,
+    reason="AGENTSEEK_TEST_REDIS_URL is required for live Redis script tests",
+)
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        pytest.param(
+            {
+                "method": "messages/partial",
+                "params": {
+                    "data": {
+                        "tool_calls": [],
+                        "invalid_tool_calls": [],
+                    }
+                },
+            },
+            id="message-with-empty-arrays",
+        ),
+        pytest.param({}, id="empty-object"),
+        pytest.param(
+            {
+                "type": "payload-event",
+                "event_id": "payload-event-id",
+                "seq": 0,
+                "method": "values",
+            },
+            id="reserved-envelope-fields",
+        ),
+    ],
+)
+@pytest.mark.asyncio
+async def test_thread_stream_lua_splices_header_without_reencoding_payload(
+    monkeypatch: pytest.MonkeyPatch,
+    payload: dict[str, object],
+) -> None:
+    assert _TEST_REDIS_URL is not None
+    redis = from_url(_TEST_REDIS_URL, decode_responses=True)
+    thread_id = 'thread-"' + "\\" + uuid4().hex[:8]
+    sequence_key = f"agentseek:threads:stream-seq:{thread_id}"
+    stream_key = f"agentseek:threads:stream:{thread_id}"
+    monkeypatch.setattr(stream_module, "_redis_client", redis)
+
+    try:
+        seq, event = await stream_module.append_redis_thread_stream_event(thread_id, payload)
+        rows = await redis.xrange(stream_key, min="-", max="+")
+    finally:
+        await redis.delete(sequence_key, stream_key)
+        await redis.aclose()
+
+    assert seq == 1
+    assert event["type"] == "event"
+    assert event["event_id"] == f"{thread_id}:1"
+    assert event["seq"] == 1
+    payload_body = {key: value for key, value in payload.items() if key not in {"type", "event_id", "seq"}}
+    expected_event = {"type": "event", "event_id": f"{thread_id}:1", "seq": 1, **payload_body}
+    assert event == expected_event
+    assert len(rows) == 1
+    stored_payload = rows[0][1]["payload"]
+    stored_event = json.loads(stored_payload)
+    assert stored_event == event
+    assert stored_payload == json.dumps(expected_event, ensure_ascii=False, separators=(",", ":"))

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/tests/integration/test_stream_persistence.py

@@ -16,7 +16,12 @@ from agentseek_api.services import run_jobs as run_jobs_module
 from agentseek_api.services import sse as sse_module
 from agentseek_api.services import stream_persistence as stream_module
 from agentseek_api.services.run_state import run_broker
-from agentseek_api.services.thread_protocol import publish_values_event, thread_protocol_broker
+from agentseek_api.services.thread_protocol import (
+    apublish_messages_complete,
+    apublish_messages_tuple,
+    publish_values_event,
+    thread_protocol_broker,
+)
 
 
 class FakeRedisCounter:
@@ -566,6 +571,85 @@ def test_create_run_stream_sends_keepalive_while_protocol_broker_is_idle(client:
     assert events[1]["data"] == {"phase": "done"}
 
 
+def test_redis_create_run_stream_replays_tool_message_tuple_for_sdk_subscribers(
+    client: TestClient,
+    monkeypatch,
+) -> None:
+    fake_redis = FakeRedisCounter()
+    monkeypatch.setattr(stream_module.settings, "EXECUTOR_BACKEND", "redis")
+    monkeypatch.setattr(stream_module, "_redis_client", fake_redis)
+    monkeypatch.setattr(runs_api, "REDIS_STREAM_POLL_INTERVAL_SECONDS", 0)
+
+    thread_id, run_id = client.portal.call(lambda: _seed_run(status="success"))
+    created = RunRead(
+        run_id=run_id,
+        thread_id=thread_id,
+        assistant_id="assistant",
+        status="success",
+        output={},
+        interrupts=None,
+        last_error=None,
+        created_at=None,
+        updated_at=None,
+        metadata={},
+        kwargs={},
+        multitask_strategy="enqueue",
+    )
+    tool_message = {
+        "content": "42 characters",
+        "additional_kwargs": {},
+        "response_metadata": {},
+        "type": "tool",
+        "name": None,
+        "id": "tool-message-1",
+        "tool_call_id": "call-character-count",
+        "artifact": None,
+        "status": "success",
+    }
+    metadata = {
+        "langgraph_node": "tools",
+        "langgraph_checkpoint_ns": "tools:task-1",
+        "provider": "deterministic",
+    }
+
+    client.portal.call(
+        lambda: apublish_messages_complete(
+            thread_id,
+            messages=[tool_message],
+            namespace=["tools:task-1"],
+            run_id=run_id,
+        )
+    )
+    client.portal.call(
+        lambda: apublish_messages_tuple(
+            thread_id,
+            chunk=tool_message,
+            metadata=metadata,
+            namespace=["tools:task-1"],
+            run_id=run_id,
+        )
+    )
+    thread_protocol_broker.delete_thread(thread_id)
+
+    response = runs_api._build_create_run_stream_response(
+        thread_id=thread_id,
+        created=created,
+        user=User(identity="default_user", is_authenticated=True),
+        stream_modes=["messages-tuple", "values"],
+        after_seq=0,
+        location=(
+            f"/threads/{thread_id}/runs/{run_id}/stream"
+            "?stream_mode=messages-tuple&stream_mode=values"
+        ),
+        content_location=f"/threads/{thread_id}/runs/{run_id}",
+    )
+
+    body = client.portal.call(_collect_stream_body, response)
+    events = _parse_sse(body)
+    assert [event["event"] for event in events] == ["metadata", "messages"]
+    assert events[1]["data"] == [tool_message, metadata]
+
+
 def test_run_stream_persistence_uses_shared_seq_after_broker_reset(client: TestClient, monkeypatch) -> None:
     fake_redis = FakeRedisCounter()
     monkeypatch.setattr(stream_module.settings, "EXECUTOR_BACKEND", "redis")

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/tests/unit/test_run_executor.py

@@ -1,7 +1,7 @@
 from typing import Any
 
 import pytest
-from langchain_core.messages import AIMessage, AIMessageChunk, HumanMessage
+from langchain_core.messages import AIMessage, AIMessageChunk, HumanMessage, ToolMessage
 from langgraph.constants import CONF, CONFIG_KEY_CHECKPOINTER
 
 from agentseek_api.core.runtime_store import UserScopedStore
@@ -752,6 +752,141 @@ class FakeProtocolMultiMessageLangGraphService(FakeLangGraphService):
         return FakeProtocolMultiMessageEntry()
 
 
+class FakeProtocolToolMessageGraph(FakeGraph):
+    async def astream_events(self, prepared_input: dict, config: dict, version: str = "v2", **kwargs):
+        self.configs.append(config)
+        tool_message = ToolMessage(
+            content="42 characters",
+            tool_call_id="call-character-count",
+            id="tool-message-1",
+        )
+        tool_event = {
+            "event": "on_chain_stream",
+            "name": "tools",
+            "run_id": "tool-run",
+            "parent_ids": ["root-run"],
+            "metadata": {
+                "langgraph_node": "tools",
+                "langgraph_checkpoint_ns": "tools:task-1",
+                "provider": "deterministic",
+            },
+            "tags": ["graph:step:2"],
+            "data": {"chunk": {"messages": [tool_message]}},
+        }
+        yield tool_event
+        yield tool_event
+        yield {
+            "event": "on_chat_model_stream",
+            "name": "chat-model",
+            "run_id": "chat-run",
+            "parent_ids": ["root-run"],
+            "metadata": {"langgraph_node": "call_model"},
+            "tags": ["graph:step:3"],
+            "data": {"chunk": AIMessageChunk(content="Final answer", id="ai-message-1")},
+        }
+        yield {
+            "event": "on_chain_end",
+            "name": "fake-graph",
+            "run_id": "root-run",
+            "parent_ids": [],
+            "metadata": {},
+            "tags": [],
+            "data": {
+                "output": {
+                    "output": {
+                        "messages": [tool_message, AIMessage(content="Final answer", id="ai-message-1")]
+                    }
+                }
+            },
+        }
+
+
+class FakeProtocolToolMessageEntry(FakeEntry):
+    graph = FakeProtocolToolMessageGraph()
+
+    @staticmethod
+    def build_graph(_checkpointer=None) -> FakeProtocolToolMessageGraph:
+        return FakeProtocolToolMessageEntry.graph
+
+
+class FakeProtocolToolMessageLangGraphService(FakeLangGraphService):
+    def get_entry(self, _graph_id: str | None) -> FakeProtocolToolMessageEntry:
+        return FakeProtocolToolMessageEntry()
+
+
+async def _execute_protocol_tool_message_graph(
+    monkeypatch: pytest.MonkeyPatch,
+    *,
+    stream_modes: list[str],
+) -> list[dict[str, Any]]:
+    fake_db = FakeDBManager()
+    protocol_broker = ThreadProtocolEventBroker()
+    FakeProtocolToolMessageEntry.graph = FakeProtocolToolMessageGraph()
+    monkeypatch.setattr(
+        "agentseek_api.services.run_executor.get_langgraph_service",
+        lambda: FakeProtocolToolMessageLangGraphService(),
+    )
+    monkeypatch.setattr("agentseek_api.services.run_executor.db_manager", fake_db)
+    monkeypatch.setattr("agentseek_api.services.thread_protocol.thread_protocol_broker", protocol_broker)
+
+    await execute_run(
+        thread_id="t1",
+        run_id="r1",
+        payload={"hello": "world"},
+        user_id="user-1",
+        kwargs={"stream_modes": stream_modes},
+    )
+    return protocol_broker._events["t1"]
+
+
+@pytest.mark.asyncio
+async def test_execute_run_mirrors_tool_message_to_requested_tuple_stream_once_and_before_final_answer(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    thread_events = await _execute_protocol_tool_message_graph(
+        monkeypatch,
+        stream_modes=["messages-tuple", "values"],
+    )
+    complete_events = [event for event in thread_events if event["method"] == "messages/complete"]
+    tuple_events = [event for event in thread_events if event["method"] == "messages-tuple"]
+    tool_tuples = [event for event in tuple_events if event["params"]["data"][0]["type"] == "tool"]
+
+    assert len(complete_events) == 1
+    assert len(tool_tuples) == 1
+
+    tool_tuple = tool_tuples[0]
+    tool_payload, metadata = tool_tuple["params"]["data"]
+    assert tool_payload["content"] == "42 characters"
+    assert tool_payload["id"] == "tool-message-1"
+    assert tool_payload["tool_call_id"] == "call-character-count"
+    assert metadata == {
+        "langgraph_node": "tools",
+        "langgraph_checkpoint_ns": "tools:task-1",
+        "provider": "deterministic",
+    }
+    assert tool_tuple["params"]["namespace"] == ["tools:task-1"]
+    assert tool_tuple["params"]["run_id"] == "r1"
+    assert complete_events[0]["params"]["data"] == [tool_payload]
+
+    final_answer_tuple = next(
+        event for event in tuple_events if event["params"]["data"][0].get("id") == "ai-message-1"
+    )
+    assert thread_events.index(tool_tuple) < thread_events.index(final_answer_tuple)
+
+
+@pytest.mark.asyncio
+async def test_execute_run_keeps_tool_message_complete_without_unrequested_tuple_mirror(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    thread_events = await _execute_protocol_tool_message_graph(monkeypatch, stream_modes=["values"])
+    complete_events = [event for event in thread_events if event["method"] == "messages/complete"]
+    tuple_events = [event for event in thread_events if event["method"] == "messages-tuple"]
+
+    assert len(complete_events) == 1
+    assert complete_events[0]["params"]["data"][0]["id"] == "tool-message-1"
+    assert tuple_events == []
+
+
 @pytest.mark.asyncio
 async def test_execute_run_publishes_incremental_protocol_messages_and_values(monkeypatch: pytest.MonkeyPatch) -> None:
     fake_db = FakeDBManager()

{agentseek_api-0.2.0 → agentseek_api-0.2.1}/uv.lock

@@ -29,7 +29,7 @@ wheels = [
 
 [[package]]
 name = "agentseek-api"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "aiomysql" },

agentseek_api-0.2.0/src/agentseek_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.2.0"