From 27c34d6af55414a69676ae682da7a675c6a9ed97 Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Mon, 26 Oct 2026 20:42:08 +0800 Subject: [PATCH 1/7] docs(sessions): describe stop and continue before a task starts The Pine server now lets stop work while the agent talks with the user (chat) and while the task is prepared (task_ready), not only while it runs; the session is kept and start continues it. Document the behavior in each state, the new errors (400 session_state_not_allowed, 429 too_many_requests), that a message alone does not continue a stopped session, and that chat() may keep waiting after a stop in chat or task_ready. No SDK code changes; the CLI help text for task start/stop is updated. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 21 ++++++++++++++++ README.md | 6 +++++ docs/http-api.md | 43 +++++++++++++++++++++++++++++---- docs/sdk-api.md | 11 +++++++-- src/pine_assistant/cli/tasks.py | 4 +-- 5 files changed, 76 insertions(+), 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index aadd94d..3eca399 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,6 +13,27 @@ project adheres to [Semantic Versioning](https://semver.org/). `platform.managed_users.create()`, and `update(email="")` removes it. A managed user without an email cannot do email tasks. +## [Unreleased] + +### Changed + +- **Stop works before the task starts.** `sessions.stop_task()` now stops the + agent while it talks with the user (`chat`) and while the task is prepared + (`task_ready`), not only while the task runs. The session is kept, and + `sessions.start_task()` continues it. A task stopped in `task_ready` does not + start on its own. A phone call that is not dialed yet is not dialed after a + stop. No SDK code changed; this needs the matching Pine server release. +- **Stop errors.** Stopping a finished or cancelled session returns 400 + `session_state_not_allowed`. Stop and start can return 429 + `too_many_requests` while another start or stop of the same session is in + progress; send the request again. +- A message sent while a session is stopped does not continue it. Send the + message, then call `start_task()`. See "Stop and continue" in + `docs/http-api.md`. +- After `stop_task()` in `chat` or `task_ready`, the `state` does not change, + so `chat()` may keep waiting on the turn. See "When a turn ends" in the + README. + ## [0.5.0rc3] - 2026-10-21 Release candidate for 0.5.0. diff --git a/README.md b/README.md index 3da3179..72bfa9c 100644 --- a/README.md +++ b/README.md @@ -311,6 +311,12 @@ async for event in client.chat(sid, "...", turn_timeout=120): ... ``` +A stop does not always end a turn. `sessions.stop_task()` in `task_processing` +moves the session to `task_paused`, which ends the turn. In `chat` or +`task_ready` the `state` does not change, so a turn that waits on work keeps +waiting. After you call `stop_task()`, stop reading that turn yourself, or use +`turn_timeout`. + Without `turn_timeout` a turn is waited on indefinitely. Note also that a task outlives the turn that started it: an outbound call reports through `session:tool_status` minutes after `chat()` has returned, which `subscribe()` diff --git a/docs/http-api.md b/docs/http-api.md index bf4965f..fdcdf16 100644 --- a/docs/http-api.md +++ b/docs/http-api.md @@ -158,8 +158,8 @@ These routes take the two headers above. | `PUT /v2/sessions/{id}/config` | Sets the caller ID. Body: `{"caller_id": "user"}` or `{"caller_id": "platform"}`. See "Caller ID". | `sessions.update_config()` | | `POST /v2/sessions/{id}/messages` | Sends a message. Body: `{"content": "...", "client_now_date": "..."}`; `client_now_date` is optional, see "The user's time". | `sessions.send_message()` | | `GET /v2/sessions/{id}/messages` | Reads the stored messages, newest first. | `sessions.history()` | -| `POST /v2/sessions/{id}/start` | Starts a prepared or paused task. | `sessions.start_task()` | -| `POST /v2/sessions/{id}/stop` | Stops a running task. | `sessions.stop_task()` | +| `POST /v2/sessions/{id}/start` | Starts a prepared or paused task, or continues a stopped session. See "Stop and continue". | `sessions.start_task()` | +| `POST /v2/sessions/{id}/stop` | Stops the agent's work and keeps the session. See "Stop and continue". | `sessions.stop_task()` | | `GET /v2/sessions/{id}/outcomes` | Lists the session's outcomes. | `sessions.outcomes()` | Routes that make the agent work can also return these errors: @@ -170,6 +170,14 @@ Routes that make the agent work can also return these errors: | 409 | `platform_session_limit_reached` | Start: the partner's running-task limit is reached. | | 409 | `platform_session_state_conflict` | Message: the session is finished or cancelled. | +Stop and start can also return: + +| Status | Code | Cause | +|---|---|---| +| 400 | `session_state_not_allowed` | Stop: the session is finished or cancelled. | +| 400 | `session_not_in_ready_state` | Start: there is nothing to start or continue. | +| 429 | `too_many_requests` | Stop or start: another start or stop of the same session is in progress. Send the request again. | + `GET /v2/sessions/{id}/messages` takes two optional query values: `limit` (1-100, default 30) and `before_message_id`. Each message has `message_id`, `type`, `version`, `data` (a JSON string) and `created_at`. To read older @@ -229,13 +237,38 @@ The session's `state` shows where the task is: | `state` | Meaning | |---|---| | `init` | The session is new. | -| `chat` | The agent talks with the user. | -| `task_ready` | The task is prepared. It usually starts on its own. If the running-task limit is reached, it stays here: call `start` later. | +| `chat` | The agent talks with the user. After a stop, the session stays in `chat` and the agent waits. | +| `task_ready` | The task is prepared. It usually starts on its own. It stays here if the running-task limit is reached, or if you stopped the session: call `start`. | | `task_processing` | The task runs. | -| `task_paused` | The task is paused, for example because the credit limit is reached. When the cause is removed, call `start` to continue. | +| `task_paused` | The task is paused because you stopped it, or because a limit is reached. Call `start` to continue (after the limit allows it). | | `task_finished` | The task is done. Read the result with `outcomes`. | | `task_cancelled` | The task was cancelled. | +### Stop and continue + +`POST /v2/sessions/{id}/stop` stops the agent and keeps the session. Use it for +a stop button: it works while the agent talks with the user, while the task is +prepared, and while the task runs. + +| `state` when you stop | What happens | +|---|---| +| `chat` | The agent starts no new action, and the task does not become ready. A reply or action already in progress finishes. The `state` stays `chat`. | +| `task_ready` | The task does not start on its own. | +| `task_processing` | The task pauses (`task_paused`). The agent starts no new action. A phone call that is not dialed yet is not dialed, and a call in progress is hung up. | +| `init`, `task_paused`, or already stopped | Nothing changes. The answer is 200. | +| `task_finished`, `task_cancelled` | 400 `session_state_not_allowed`. | + +To continue, call `POST /v2/sessions/{id}/start`. A message that the user sends +while the session is stopped is saved, and the agent reads it when the session +continues. Sending a message does not continue the session by itself. So when +the user writes after a stop, send the message and then call `start`. + +`start` checks your limits as for any start: it can return 402, 403 or 409 (see +the tables above). Then the session stays stopped; call `start` again later. + +Do not use `DELETE /v2/sessions/{id}` as a stop. It deletes the session, and +the user cannot continue it. + ### Talk with the agent We recommend Socket.IO ([docs/socketio.md](socketio.md)) to talk with the diff --git a/docs/sdk-api.md b/docs/sdk-api.md index 7e1b4da..47db5d8 100644 --- a/docs/sdk-api.md +++ b/docs/sdk-api.md @@ -134,8 +134,15 @@ user = await partner_client.platform.managed_users.update( The agent talks with the user, prepares the task, and then starts it on its own, as it does for a normal Pine user. `sessions.get()` returns the session's `state`. The states are listed in [docs/http-api.md](http-api.md#how-a-task-runs). -Use `sessions.start_task()` only for a task that did not start on its own or -that is paused. +Use `sessions.start_task()` only for a task that did not start on its own, that +is paused, or that you stopped. + +`sessions.stop_task()` stops the agent and keeps the session, in `chat`, +`task_ready` and `task_processing`. To continue, call `sessions.start_task()`; +when the user writes after a stop, send the message first and then call +`start_task()`. A message alone does not continue a stopped session. The +details and errors are in +[docs/http-api.md](http-api.md#stop-and-continue). Without Socket.IO, send with `sessions.send_message()` and read the replies with `sessions.history()`. Each message has `message_id`, `type`, `version`, diff --git a/src/pine_assistant/cli/tasks.py b/src/pine_assistant/cli/tasks.py index d0cea87..3aea38a 100644 --- a/src/pine_assistant/cli/tasks.py +++ b/src/pine_assistant/cli/tasks.py @@ -24,7 +24,7 @@ def task(): @task.command("start") @click.argument("session_id") def task_start(session_id): - """Start task execution (requires task_ready).""" + """Start a prepared task, or continue a paused or stopped session.""" async def _start(): client = _get_client() @@ -38,7 +38,7 @@ async def _start(): @task.command("stop") @click.argument("session_id") def task_stop(session_id): - """Stop a running task.""" + """Stop the agent's work and keep the session.""" async def _stop(): client = _get_client() From e377345abc518526d0ece0d42f08de7986b36b2d Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Mon, 26 Oct 2026 23:56:14 +0800 Subject: [PATCH 2/7] docs(sessions): trim stop and continue; either order of message and start Remove text that repeated the "Stop and continue" table or the error tables, the note about DELETE, and the copy in sdk-api.md (it links to the section). Say that a message can be sent before or after start, and why sending it first is better. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 10 ++++------ docs/http-api.md | 23 +++++++++-------------- docs/sdk-api.md | 10 ++-------- 3 files changed, 15 insertions(+), 28 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3eca399..9c24354 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,16 +20,14 @@ project adheres to [Semantic Versioning](https://semver.org/). - **Stop works before the task starts.** `sessions.stop_task()` now stops the agent while it talks with the user (`chat`) and while the task is prepared (`task_ready`), not only while the task runs. The session is kept, and - `sessions.start_task()` continues it. A task stopped in `task_ready` does not - start on its own. A phone call that is not dialed yet is not dialed after a - stop. No SDK code changed; this needs the matching Pine server release. + `sessions.start_task()` continues it; a message alone does not. A task + stopped in `task_ready` does not start on its own. A phone call that is not + dialed yet is not dialed after a stop. No SDK code changed; this needs the + matching Pine server release. - **Stop errors.** Stopping a finished or cancelled session returns 400 `session_state_not_allowed`. Stop and start can return 429 `too_many_requests` while another start or stop of the same session is in progress; send the request again. -- A message sent while a session is stopped does not continue it. Send the - message, then call `start_task()`. See "Stop and continue" in - `docs/http-api.md`. - After `stop_task()` in `chat` or `task_ready`, the `state` does not change, so `chat()` may keep waiting on the turn. See "When a turn ends" in the README. diff --git a/docs/http-api.md b/docs/http-api.md index fdcdf16..fd2b7e8 100644 --- a/docs/http-api.md +++ b/docs/http-api.md @@ -237,7 +237,7 @@ The session's `state` shows where the task is: | `state` | Meaning | |---|---| | `init` | The session is new. | -| `chat` | The agent talks with the user. After a stop, the session stays in `chat` and the agent waits. | +| `chat` | The agent talks with the user. | | `task_ready` | The task is prepared. It usually starts on its own. It stays here if the running-task limit is reached, or if you stopped the session: call `start`. | | `task_processing` | The task runs. | | `task_paused` | The task is paused because you stopped it, or because a limit is reached. Call `start` to continue (after the limit allows it). | @@ -246,9 +246,7 @@ The session's `state` shows where the task is: ### Stop and continue -`POST /v2/sessions/{id}/stop` stops the agent and keeps the session. Use it for -a stop button: it works while the agent talks with the user, while the task is -prepared, and while the task runs. +`POST /v2/sessions/{id}/stop` stops the agent and keeps the session: | `state` when you stop | What happens | |---|---| @@ -256,18 +254,15 @@ prepared, and while the task runs. | `task_ready` | The task does not start on its own. | | `task_processing` | The task pauses (`task_paused`). The agent starts no new action. A phone call that is not dialed yet is not dialed, and a call in progress is hung up. | | `init`, `task_paused`, or already stopped | Nothing changes. The answer is 200. | -| `task_finished`, `task_cancelled` | 400 `session_state_not_allowed`. | -To continue, call `POST /v2/sessions/{id}/start`. A message that the user sends -while the session is stopped is saved, and the agent reads it when the session -continues. Sending a message does not continue the session by itself. So when -the user writes after a stop, send the message and then call `start`. +To continue, call `POST /v2/sessions/{id}/start`. A message sent while the +session is stopped is saved but does not continue it. You can send the user's +message before or after `start`; before is better, because the agent then reads +the message before it goes on. If you start first, the agent may continue the +stopped step (for example, place the call) before the message arrives. -`start` checks your limits as for any start: it can return 402, 403 or 409 (see -the tables above). Then the session stays stopped; call `start` again later. - -Do not use `DELETE /v2/sessions/{id}` as a stop. It deletes the session, and -the user cannot continue it. +If `start` is refused by a limit, the session stays stopped; call `start` again +later. ### Talk with the agent diff --git a/docs/sdk-api.md b/docs/sdk-api.md index 47db5d8..83f6af4 100644 --- a/docs/sdk-api.md +++ b/docs/sdk-api.md @@ -135,14 +135,8 @@ The agent talks with the user, prepares the task, and then starts it on its own, as it does for a normal Pine user. `sessions.get()` returns the session's `state`. The states are listed in [docs/http-api.md](http-api.md#how-a-task-runs). Use `sessions.start_task()` only for a task that did not start on its own, that -is paused, or that you stopped. - -`sessions.stop_task()` stops the agent and keeps the session, in `chat`, -`task_ready` and `task_processing`. To continue, call `sessions.start_task()`; -when the user writes after a stop, send the message first and then call -`start_task()`. A message alone does not continue a stopped session. The -details and errors are in -[docs/http-api.md](http-api.md#stop-and-continue). +is paused, or that you stopped with `sessions.stop_task()`. See +[Stop and continue](http-api.md#stop-and-continue). Without Socket.IO, send with `sessions.send_message()` and read the replies with `sessions.history()`. Each message has `message_id`, `type`, `version`, From f895472588b131eafd58d9c9db870f1527683da0 Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Mon, 26 Oct 2026 23:59:46 +0800 Subject: [PATCH 3/7] docs(sessions): drop the turn note that repeats "When a turn ends" Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 3 --- README.md | 6 ------ 2 files changed, 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9c24354..9c729aa 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -28,9 +28,6 @@ project adheres to [Semantic Versioning](https://semver.org/). `session_state_not_allowed`. Stop and start can return 429 `too_many_requests` while another start or stop of the same session is in progress; send the request again. -- After `stop_task()` in `chat` or `task_ready`, the `state` does not change, - so `chat()` may keep waiting on the turn. See "When a turn ends" in the - README. ## [0.5.0rc3] - 2026-10-21 diff --git a/README.md b/README.md index 72bfa9c..3da3179 100644 --- a/README.md +++ b/README.md @@ -311,12 +311,6 @@ async for event in client.chat(sid, "...", turn_timeout=120): ... ``` -A stop does not always end a turn. `sessions.stop_task()` in `task_processing` -moves the session to `task_paused`, which ends the turn. In `chat` or -`task_ready` the `state` does not change, so a turn that waits on work keeps -waiting. After you call `stop_task()`, stop reading that turn yourself, or use -`turn_timeout`. - Without `turn_timeout` a turn is waited on indefinitely. Note also that a task outlives the turn that started it: an outbound call reports through `session:tool_status` minutes after `chat()` has returned, which `subscribe()` From e52d4552c947254ba80048fe7ac66ea89a010b10 Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Tue, 27 Oct 2026 00:06:20 +0800 Subject: [PATCH 4/7] docs(sessions): keep the task_ready state row as it was Co-Authored-By: Claude Opus 5.5 --- docs/http-api.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/http-api.md b/docs/http-api.md index fd2b7e8..d760355 100644 --- a/docs/http-api.md +++ b/docs/http-api.md @@ -238,7 +238,7 @@ The session's `state` shows where the task is: |---|---| | `init` | The session is new. | | `chat` | The agent talks with the user. | -| `task_ready` | The task is prepared. It usually starts on its own. It stays here if the running-task limit is reached, or if you stopped the session: call `start`. | +| `task_ready` | The task is prepared. It usually starts on its own. If the running-task limit is reached, it stays here: call `start` later. | | `task_processing` | The task runs. | | `task_paused` | The task is paused because you stopped it, or because a limit is reached. Call `start` to continue (after the limit allows it). | | `task_finished` | The task is done. Read the result with `outcomes`. | From ac275b39dce54412d1248ca0941a0fb837d183b6 Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Tue, 27 Oct 2026 00:07:29 +0800 Subject: [PATCH 5/7] docs(sessions): drop "keeps the session" from stop Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 4 ++-- docs/http-api.md | 4 ++-- src/pine_assistant/cli/tasks.py | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9c729aa..949a7ac 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,8 +19,8 @@ project adheres to [Semantic Versioning](https://semver.org/). - **Stop works before the task starts.** `sessions.stop_task()` now stops the agent while it talks with the user (`chat`) and while the task is prepared - (`task_ready`), not only while the task runs. The session is kept, and - `sessions.start_task()` continues it; a message alone does not. A task + (`task_ready`), not only while the task runs. `sessions.start_task()` + continues it; a message alone does not. A task stopped in `task_ready` does not start on its own. A phone call that is not dialed yet is not dialed after a stop. No SDK code changed; this needs the matching Pine server release. diff --git a/docs/http-api.md b/docs/http-api.md index d760355..c87da25 100644 --- a/docs/http-api.md +++ b/docs/http-api.md @@ -159,7 +159,7 @@ These routes take the two headers above. | `POST /v2/sessions/{id}/messages` | Sends a message. Body: `{"content": "...", "client_now_date": "..."}`; `client_now_date` is optional, see "The user's time". | `sessions.send_message()` | | `GET /v2/sessions/{id}/messages` | Reads the stored messages, newest first. | `sessions.history()` | | `POST /v2/sessions/{id}/start` | Starts a prepared or paused task, or continues a stopped session. See "Stop and continue". | `sessions.start_task()` | -| `POST /v2/sessions/{id}/stop` | Stops the agent's work and keeps the session. See "Stop and continue". | `sessions.stop_task()` | +| `POST /v2/sessions/{id}/stop` | Stops the agent. See "Stop and continue". | `sessions.stop_task()` | | `GET /v2/sessions/{id}/outcomes` | Lists the session's outcomes. | `sessions.outcomes()` | Routes that make the agent work can also return these errors: @@ -246,7 +246,7 @@ The session's `state` shows where the task is: ### Stop and continue -`POST /v2/sessions/{id}/stop` stops the agent and keeps the session: +`POST /v2/sessions/{id}/stop` stops the agent: | `state` when you stop | What happens | |---|---| diff --git a/src/pine_assistant/cli/tasks.py b/src/pine_assistant/cli/tasks.py index 3aea38a..b368c15 100644 --- a/src/pine_assistant/cli/tasks.py +++ b/src/pine_assistant/cli/tasks.py @@ -38,7 +38,7 @@ async def _start(): @task.command("stop") @click.argument("session_id") def task_stop(session_id): - """Stop the agent's work and keep the session.""" + """Stop the agent.""" async def _stop(): client = _get_client() From d88f9128304078345e1937f1d2b46d151bd18ae8 Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Tue, 27 Oct 2026 00:09:06 +0800 Subject: [PATCH 6/7] docs(sessions): tighten stop wording and trim the changelog - chat row: the task does not start on its own (it can still become ready). - 429: the session is busy with another change, not only a start or stop. - Remove the refused-start paragraph and the changelog's error list and per-state detail; both repeat the "Stop and continue" section. Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 15 ++++----------- docs/http-api.md | 7 ++----- 2 files changed, 6 insertions(+), 16 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 949a7ac..4482cc1 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,17 +17,10 @@ project adheres to [Semantic Versioning](https://semver.org/). ### Changed -- **Stop works before the task starts.** `sessions.stop_task()` now stops the - agent while it talks with the user (`chat`) and while the task is prepared - (`task_ready`), not only while the task runs. `sessions.start_task()` - continues it; a message alone does not. A task - stopped in `task_ready` does not start on its own. A phone call that is not - dialed yet is not dialed after a stop. No SDK code changed; this needs the - matching Pine server release. -- **Stop errors.** Stopping a finished or cancelled session returns 400 - `session_state_not_allowed`. Stop and start can return 429 - `too_many_requests` while another start or stop of the same session is in - progress; send the request again. +- **Stop works before the task starts.** `sessions.stop_task()` now also stops + the agent in `chat` and `task_ready`, and `sessions.start_task()` continues + the session. See "Stop and continue" in `docs/http-api.md`. No SDK code + changed; this needs the matching Pine server release. ## [0.5.0rc3] - 2026-10-21 diff --git a/docs/http-api.md b/docs/http-api.md index c87da25..1575fc9 100644 --- a/docs/http-api.md +++ b/docs/http-api.md @@ -176,7 +176,7 @@ Stop and start can also return: |---|---|---| | 400 | `session_state_not_allowed` | Stop: the session is finished or cancelled. | | 400 | `session_not_in_ready_state` | Start: there is nothing to start or continue. | -| 429 | `too_many_requests` | Stop or start: another start or stop of the same session is in progress. Send the request again. | +| 429 | `too_many_requests` | Stop or start: the session is busy with another change. Send the request again. | `GET /v2/sessions/{id}/messages` takes two optional query values: `limit` (1-100, default 30) and `before_message_id`. Each message has `message_id`, @@ -250,7 +250,7 @@ The session's `state` shows where the task is: | `state` when you stop | What happens | |---|---| -| `chat` | The agent starts no new action, and the task does not become ready. A reply or action already in progress finishes. The `state` stays `chat`. | +| `chat` | The agent starts no new action, and the task does not start on its own. A reply or action already in progress finishes. The `state` stays `chat`. | | `task_ready` | The task does not start on its own. | | `task_processing` | The task pauses (`task_paused`). The agent starts no new action. A phone call that is not dialed yet is not dialed, and a call in progress is hung up. | | `init`, `task_paused`, or already stopped | Nothing changes. The answer is 200. | @@ -261,9 +261,6 @@ message before or after `start`; before is better, because the agent then reads the message before it goes on. If you start first, the agent may continue the stopped step (for example, place the call) before the message arrives. -If `start` is refused by a limit, the session stays stopped; call `start` again -later. - ### Talk with the agent We recommend Socket.IO ([docs/socketio.md](socketio.md)) to talk with the From fb93ec95a3fe66f7f07126c6872714cea04e5da3 Mon Sep 17 00:00:00 2001 From: Charlie-Qilin Date: Tue, 27 Oct 2026 15:34:38 +0800 Subject: [PATCH 7/7] docs(sessions): drop the changelog entry; no SDK change ships Co-Authored-By: Claude Opus 5.5 --- CHANGELOG.md | 9 --------- 1 file changed, 9 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 4482cc1..aadd94d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -13,15 +13,6 @@ project adheres to [Semantic Versioning](https://semver.org/). `platform.managed_users.create()`, and `update(email="")` removes it. A managed user without an email cannot do email tasks. -## [Unreleased] - -### Changed - -- **Stop works before the task starts.** `sessions.stop_task()` now also stops - the agent in `chat` and `task_ready`, and `sessions.start_task()` continues - the session. See "Stop and continue" in `docs/http-api.md`. No SDK code - changed; this needs the matching Pine server release. - ## [0.5.0rc3] - 2026-10-21 Release candidate for 0.5.0.