Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

Keep Code session prompts in conversation order (#1720)

Ali Khokharbdbff1cacd8e
diff --git a/e2e/test_code_sessions.py b/e2e/test_code_sessions.py
index fd9ff243..40754b07 100644
--- a/e2e/test_code_sessions.py
+++ b/e2e/test_code_sessions.py
@@ -368,6 +368,21 @@ def test_prompt_claim_syncs_tabs_and_stop_keeps_output(
expect(second.get_by_role("button", name="Allow", exact=True)).to_be_enabled()
page.get_by_role("button", name="Allow", exact=True).click()
expect(second.get_by_role("button", name="Allow", exact=True)).to_be_disabled()
+ code_control.run(
+ connection.text("turn-1", "after", "Output after approval", complete=True)
+ )
+ expect(
+ second.locator(
+ "#codeTranscript .code-prose, #codeTranscript .code-prompt h3"
+ )
+ ).to_have_text(
+ [
+ "Run a command",
+ "Output before approval",
+ "Run command?",
+ "Output after approval",
+ ]
+ )
page.get_by_role("button", name="Stop", exact=True).click()
page.get_by_role("textbox", name="Message", exact=True).fill("Follow up")
expect(page.get_by_role("button", name="Send", exact=True)).to_be_enabled()
@@ -408,6 +423,10 @@ def test_old_detail_cannot_replace_streamed_output(
expect(page.get_by_role("button", name="Send", exact=True)).to_be_visible()
expect(page.get_by_role("button", name="Allow", exact=True)).to_be_disabled()
+ expect(page.locator(".code-prompt")).to_have_count(1)
+ expect(page.locator(".code-run-items > .code-prompt")).to_have_count(1)
+ expect(page.locator(".code-prompt-state")).to_have_text("Resolved")
+
def test_competing_tabs_keep_the_rejected_draft(
page, context, admin_base_url, tmp_path, code_control
@@ -499,6 +518,87 @@ def test_rename_and_delete_sync_library_without_touching_project(
second.close()
+def test_answered_question_keeps_its_place_across_turns_tabs_and_refresh(
+ page, context, admin_base_url, tmp_path, code_control
+):
+ url = create_session(page, admin_base_url, tmp_path)
+ send(page, "First request")
+ connection = code_control.connection()
+ code_control.run(
+ connection.text("turn-1", "before", "Before question", complete=True)
+ )
+ prompt = PromptRequest(
+ 7,
+ "questions",
+ {
+ "title": "Question at this point",
+ "questions": [
+ {
+ "id": "task",
+ "label": "Which task?",
+ "options": [{"label": "Search", "description": "Search docs"}],
+ "allow_other": False,
+ "secret": False,
+ }
+ ],
+ },
+ {},
+ "turn-1",
+ "question-without-a-native-transcript-item",
+ )
+
+ async def ask():
+ connection.requests[7] = prompt
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "prompt",
+ turn_id="turn-1",
+ prompt=prompt,
+ )
+ )
+
+ code_control.run(ask())
+ second = context.new_page()
+ try:
+ second.goto(url)
+ expect(second.get_by_text("Which task?", exact=True)).to_be_visible()
+ page.get_by_role("radio").check()
+ page.get_by_role("button", name="Submit answers", exact=True).click()
+ expect(second.locator(".code-prompt-state")).to_have_text("Resolved")
+ code_control.run(
+ connection.text("turn-1", "after", "After answer", complete=True)
+ )
+ code_control.run(connection.finish("turn-1"))
+ send(page, "Second request")
+ code_control.run(code_control.harness.wait_inputs(2))
+ code_control.run(
+ connection.text("turn-2", "reply", "Second reply", complete=True)
+ )
+ code_control.run(connection.finish("turn-2"))
+ expected = [
+ "First request",
+ "Before question",
+ "Which task?",
+ "After answer",
+ "Second request",
+ "Second reply",
+ ]
+ for tab in (page, second):
+ expect(tab.get_by_text("Second reply", exact=True)).to_be_visible()
+ entries = tab.locator(
+ "#codeTranscript .code-prose, #codeTranscript .code-prompt legend"
+ )
+ expect(entries).to_have_text(expected)
+ tab.reload()
+ expect(entries).to_have_text(expected)
+ expect(tab.locator(".code-prompt-state")).to_have_text("Resolved")
+ assert connection.answers == [(7, {"answers": {"task": ["Search"]}})]
+ finally:
+ second.close()
+
+
def test_question_input_survives_streaming_and_secret_answer_is_not_stored(
page, admin_base_url, tmp_path, code_control
):
@@ -547,16 +647,36 @@ def test_question_input_survives_streaming_and_secret_answer_is_not_stored(
secret = page.get_by_label("Your answer", exact=True)
secret.fill("private-answer")
expect(secret).to_have_attribute("type", "password")
+ secret.focus()
+ secret.evaluate(
+ "input => { window.savedPromptInput = input; input.setSelectionRange(2, 6); }"
+ )
code_control.run(
connection.text("turn-1", "stream", "Still checking", complete=True)
)
expect(page.get_by_text("Still checking", exact=True)).to_be_visible()
expect(secret).to_have_value("private-answer")
+ expect(secret).to_be_focused()
+ assert secret.evaluate(
+ "input => input === window.savedPromptInput && input.selectionStart === 2 && input.selectionEnd === 6"
+ )
page.evaluate("window.codeFeed.onerror(new Event('error'))")
expect(
page.get_by_role("button", name="Submit answers", exact=True)
).to_be_enabled()
expect(secret).to_have_value("private-answer")
+ assert secret.evaluate(
+ "input => input === window.savedPromptInput && input.selectionStart === 2 && input.selectionEnd === 6"
+ )
+ expect(
+ page.locator("#codeTranscript .code-prompt legend, #codeTranscript .code-prose")
+ ).to_have_text(
+ [
+ "Ask me a question",
+ "Which destination?",
+ "Still checking",
+ ]
+ )
page.get_by_role("button", name="Submit answers", exact=True).click()
expect(
page.get_by_role("button", name="Submit answers", exact=True)
@@ -568,7 +688,8 @@ def test_question_input_survives_streaming_and_secret_answer_is_not_stored(
code_control.service.get_detail(page.url.rsplit("/", 1)[1])
)
assert all(
- "private-answer" not in value.model_dump_json() for value in detail.prompts
+ "private-answer" not in value.model_dump_json()
+ for value in (*detail.prompts, *detail.items)
)
diff --git a/src/free_claude_code/api/admin_static/code_sessions.js b/src/free_claude_code/api/admin_static/code_sessions.js
index 3d57cee4..706b3651 100644
--- a/src/free_claude_code/api/admin_static/code_sessions.js
+++ b/src/free_claude_code/api/admin_static/code_sessions.js
@@ -827,11 +827,7 @@
"secondary-button session-older",
);
older.id = "codeOlder";
- transcript.append(
- older,
- element("div", undefined, "code-items"),
- element("div", undefined, "code-prompts"),
- );
+ transcript.append(older, element("div", undefined, "code-items"));
const composer = UI.composer(
"code",
saved(id).draft || "",
@@ -986,9 +982,6 @@
run.error ||
(run.status === "interrupted" ? "Turn stopped." : "This turn failed.");
}
- const prompts = root.querySelector(".code-prompts");
- for (const { value: prompt } of record?.prompts.values() || [])
- renderPrompt(prompts, prompt);
if (bottom) transcript.scrollTop = transcript.scrollHeight;
root.querySelector("#codeOlder").hidden = !record?.nextBefore;
renderControls();
@@ -1069,6 +1062,11 @@
}
function renderItem(parent, item) {
+ if (item.kind === "prompt") {
+ const prompt = records.get(selected).prompts.get(item.id)?.value;
+ if (prompt) renderPrompt(parent, prompt, item.sequence);
+ return;
+ }
let node = parent.querySelector(`[data-id="${CSS.escape(item.id)}"]`);
if (!node) {
node = UI.message(
@@ -1095,11 +1093,7 @@
),
element("pre", "", "code-item-detail"),
);
- node.dataset.sequence = item.sequence;
- const next = [...parent.children].find(
- (child) => Number(child.dataset.sequence) > item.sequence,
- );
- parent.insertBefore(node, next || null);
+ insertEntry(parent, node, item.sequence);
}
const content = node.querySelector(".code-prose"),
value = item.html ?? item.text;
@@ -1113,7 +1107,15 @@
detail.hidden = !item.detail;
}
- function renderPrompt(parent, prompt) {
+ function insertEntry(parent, node, sequence) {
+ node.dataset.sequence = sequence;
+ const next = [...parent.children].find(
+ (child) => Number(child.dataset.sequence) > sequence,
+ );
+ parent.insertBefore(node, next || null);
+ }
+
+ function renderPrompt(parent, prompt, sequence) {
let node = parent.querySelector(`[data-id="${CSS.escape(prompt.id)}"]`);
if (!node) {
node = element("form", undefined, "code-prompt");
@@ -1124,7 +1126,7 @@
);
buildPrompt(node, prompt);
node.append(element("p", "", "code-prompt-state"));
- parent.append(node);
+ insertEntry(parent, node, sequence);
}
node.querySelector(".code-prompt-state").textContent =
prompt.error ||
diff --git a/src/free_claude_code/application/code_sessions/models.py b/src/free_claude_code/application/code_sessions/models.py
index 8d880285..df0b1aff 100644
--- a/src/free_claude_code/application/code_sessions/models.py
+++ b/src/free_claude_code/application/code_sessions/models.py
@@ -72,6 +72,8 @@ class CodeItem(Record):
class CodePrompt(Record):
+ """Form and response state for the prompt CodeItem with the same session/id."""
+
id: str
session_id: str
generation: str
diff --git a/src/free_claude_code/application/code_sessions/service.py b/src/free_claude_code/application/code_sessions/service.py
index 12eb9cf5..3c62cd3f 100644
--- a/src/free_claude_code/application/code_sessions/service.py
+++ b/src/free_claude_code/application/code_sessions/service.py
@@ -285,20 +285,19 @@ class CodeService:
active = [
item
for item in owner.items.values()
- if owner.busy and owner.run and item.run_id == owner.run.id
+ if (owner.busy and owner.run and item.run_id == owner.run.id)
+ or (
+ item.kind == "prompt"
+ and owner.prompts[item.id].status in {"pending", "answering"}
+ )
]
selected = sorted(
{item.id: item for item in [*page.items, *active]}.values(),
key=lambda item: (owner.runs[item.run_id].ordinal, item.sequence),
)
- turns = {item.native_turn_id for item in selected if item.native_turn_id}
- if owner.run and owner.run.native_turn_id:
- turns.add(owner.run.native_turn_id)
+ prompt_ids = {item.id for item in selected if item.kind == "prompt"}
prompts = tuple(
- prompt
- for prompt in owner.prompts.values()
- if prompt.status in {"pending", "answering"}
- or prompt.native_turn_id in turns
+ prompt for prompt in owner.prompts.values() if prompt.id in prompt_ids
)
return CodeDetail(
owner.session,
@@ -312,7 +311,11 @@ class CodeService:
tuple(
{
run.id: run
- for run in (*page.runs, *((owner.run,) if owner.run else ()))
+ for run in (
+ *page.runs,
+ *(owner.runs[item.run_id] for item in active),
+ *((owner.run,) if owner.run else ()),
+ )
}.values()
),
tuple(
@@ -518,9 +521,7 @@ class CodeService:
session_id, prompt_id, response_id, connection.generation
)
owner.prompts[prompt_id] = claimed
- self._publish(
- owner, "prompt.updated", prompt=claimed.model_dump(mode="json")
- )
+ self._publish_prompt(owner, claimed)
self._job(self._deliver_answer(owner, claimed, response))
return claimed
@@ -800,9 +801,7 @@ class CodeService:
resolved = current.model_copy(update={"status": "resolved"})
await self._persist(owner, owner.session, prompts=(resolved,))
owner.prompts[prompt.id] = resolved
- self._publish(
- owner, "prompt.updated", prompt=resolved.model_dump(mode="json")
- )
+ self._publish_prompt(owner, resolved)
except CodeConflictError:
async with owner.lock:
current = owner.prompts.get(prompt.id)
@@ -810,9 +809,7 @@ class CodeService:
expired = current.model_copy(update={"status": "expired"})
await self._persist(owner, owner.session, prompts=(expired,))
owner.prompts[prompt.id] = expired
- self._publish(
- owner, "prompt.updated", prompt=expired.model_dump(mode="json")
- )
+ self._publish_prompt(owner, expired)
except Exception as exc:
if owner.run and owner.busy:
await self._fail(
@@ -900,11 +897,25 @@ class CodeService:
form=request.form,
raw=request.raw,
)
- await self._persist(owner, owner.session, prompts=(prompt,))
- owner.prompts[prompt.id] = prompt
- self._publish(
- owner, "prompt.updated", prompt=prompt.model_dump(mode="json")
+ if run is None:
+ raise CodeUnavailableError(
+ "Codex returned a prompt without a saved turn."
+ )
+ item = CodeItem(
+ id=prompt.id,
+ session_id=owner.session.id,
+ run_id=run.id,
+ sequence=owner.sequence + 1,
+ kind="prompt",
+ complete=True,
+ )
+ await self._persist(
+ owner, owner.session, items=(item,), prompts=(prompt,)
)
+ owner.items[item.id] = item
+ owner.sequence = item.sequence
+ owner.prompts[prompt.id] = prompt
+ self._publish_prompt(owner, prompt)
elif event.kind == "resolved":
for prompt in tuple(owner.prompts.values()):
if (
@@ -917,11 +928,7 @@ class CodeService:
owner, owner.session, prompts=(resolved,)
)
owner.prompts[prompt.id] = resolved
- self._publish(
- owner,
- "prompt.updated",
- prompt=resolved.model_dump(mode="json"),
- )
+ self._publish_prompt(owner, resolved)
elif event.kind == "error" and matches:
self._publish(
owner,
@@ -1080,9 +1087,7 @@ class CodeService:
await self._persist(owner, owner.session, prompts=prompts)
for prompt in prompts:
owner.prompts[prompt.id] = prompt
- self._publish(
- owner, "prompt.updated", prompt=prompt.model_dump(mode="json")
- )
+ self._publish_prompt(owner, prompt)
async def _persist(
self,
@@ -1257,6 +1262,16 @@ class CodeService:
payload[key] = value
self._events.publish(event, payload)
+ def _publish_prompt(self, owner: _Owner, prompt: CodePrompt) -> None:
+ item = owner.items[prompt.id]
+ self._publish(
+ owner,
+ "prompt.updated",
+ prompt=prompt.model_dump(mode="json"),
+ item=item.model_dump(mode="json"),
+ runs=[owner.runs[item.run_id].model_dump(mode="json")],
+ )
+
def _validate_id(value: str) -> None:
try:
diff --git a/src/free_claude_code/runtime/code_sessions_sqlite.py b/src/free_claude_code/runtime/code_sessions_sqlite.py
index c4213598..a828e38b 100644
--- a/src/free_claude_code/runtime/code_sessions_sqlite.py
+++ b/src/free_claude_code/runtime/code_sessions_sqlite.py
@@ -240,6 +240,12 @@ def _write_item(connection: sqlite3.Connection, item: CodeItem) -> None:
def _write_prompt(connection: sqlite3.Connection, prompt: CodePrompt) -> None:
+ item = connection.execute(
+ "SELECT kind FROM code_items WHERE session_id = ? AND id = ?",
+ (prompt.session_id, prompt.id),
+ ).fetchone()
+ if item is None or item["kind"] != "prompt":
+ raise CodeConflictError("This prompt requires its own transcript entry.")
row = connection.execute(
"SELECT * FROM code_prompts WHERE session_id = ? AND id = ?",
(prompt.session_id, prompt.id),
@@ -278,6 +284,55 @@ def _write_prompt(connection: sqlite3.Connection, prompt: CodePrompt) -> None:
)
+def _migrate_prompt_entries(connection: sqlite3.Connection) -> None:
+ """Give old prompts a permanent run-end position without rewriting history."""
+ for row in connection.execute(
+ "SELECT * FROM code_prompts ORDER BY rowid"
+ ).fetchall():
+ prompt = _record(CodePrompt, row)
+ run = connection.execute(
+ "SELECT id FROM code_runs WHERE session_id = ? AND native_turn_id = ?",
+ (prompt.session_id, prompt.native_turn_id),
+ ).fetchone()
+ if run is None and prompt.native_item_id is not None:
+ matches = connection.execute(
+ "SELECT DISTINCT run_id AS id FROM code_items WHERE session_id = ? AND native_item_id = ?",
+ (prompt.session_id, prompt.native_item_id),
+ ).fetchall()
+ if len(matches) == 1:
+ run = matches[0]
+ if run is None:
+ run = connection.execute(
+ "SELECT id FROM code_runs WHERE session_id = ? ORDER BY ordinal DESC LIMIT 1",
+ (prompt.session_id,),
+ ).fetchone()
+ if run is None:
+ raise CodeUnavailableError("A saved prompt has no saved conversation turn.")
+ sequence = connection.execute(
+ "SELECT COALESCE(MAX(sequence), 0) + 1 FROM code_items WHERE session_id = ?",
+ (prompt.session_id,),
+ ).fetchone()[0]
+ _insert(
+ connection,
+ "code_items",
+ CodeItem(
+ id=prompt.id,
+ session_id=prompt.session_id,
+ run_id=run["id"],
+ sequence=sequence,
+ kind="prompt",
+ complete=True,
+ ),
+ )
+ connection.execute("CREATE TABLE code_prompts_new" + _PROMPT_COLUMNS)
+ connection.execute("INSERT INTO code_prompts_new SELECT * FROM code_prompts")
+ connection.execute("DROP TABLE code_prompts")
+ connection.execute("ALTER TABLE code_prompts_new RENAME TO code_prompts")
+ if connection.execute("PRAGMA foreign_key_check").fetchone() is not None:
+ raise CodeUnavailableError("Code session history has an invalid record link.")
+ connection.execute("PRAGMA user_version = 1")
+
+
class SQLiteCodeStore:
def __init__(self, database_path: Path, lock_path: Path) -> None:
self._path = database_path
@@ -346,6 +401,8 @@ class SQLiteCodeStore:
connection.execute("PRAGMA journal_mode = WAL")
connection.executescript(_SCHEMA)
connection.execute("BEGIN IMMEDIATE")
+ if connection.execute("PRAGMA user_version").fetchone()[0] == 0:
+ _migrate_prompt_entries(connection)
connection.execute(
"UPDATE code_runs SET status = 'interrupted', finished_at = ?, error = ? "
"WHERE status IN ('preparing','running','stopping')",
@@ -645,7 +702,17 @@ class SQLiteCodeStore:
await self._run(operation)
-_SCHEMA = """
+_PROMPT_COLUMNS = """(
+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,
+ generation TEXT NOT NULL, request_id TEXT NOT NULL, native_turn_id TEXT, native_item_id TEXT,
+ kind TEXT NOT NULL, form TEXT NOT NULL, raw TEXT NOT NULL,
+ status TEXT NOT NULL CHECK(status IN ('pending','answering','resolved','expired')), response_id TEXT, error TEXT,
+ PRIMARY KEY(session_id,id), UNIQUE(session_id,generation,request_id), UNIQUE(session_id,response_id),
+ FOREIGN KEY(session_id,id) REFERENCES code_items(session_id,id) ON DELETE CASCADE
+)"""
+
+_SCHEMA = (
+ """
CREATE TABLE IF NOT EXISTS code_sessions(
id TEXT PRIMARY KEY NOT NULL, cwd TEXT NOT NULL, model TEXT NOT NULL, reasoning_effort TEXT,
harness TEXT NOT NULL CHECK(harness = 'codex'), title TEXT NOT NULL, title_search TEXT NOT NULL,
@@ -675,12 +742,9 @@ CREATE TABLE IF NOT EXISTS code_items(
UNIQUE(session_id,sequence), UNIQUE(session_id,native_turn_id,native_item_id)
);
CREATE INDEX IF NOT EXISTS code_items_run ON code_items(session_id,run_id,sequence);
-CREATE TABLE IF NOT EXISTS code_prompts(
- session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE, id TEXT NOT NULL,
- generation TEXT NOT NULL, request_id TEXT NOT NULL, native_turn_id TEXT, native_item_id TEXT,
- kind TEXT NOT NULL, form TEXT NOT NULL, raw TEXT NOT NULL,
- status TEXT NOT NULL CHECK(status IN ('pending','answering','resolved','expired')), response_id TEXT, error TEXT,
- PRIMARY KEY(session_id,id), UNIQUE(session_id,generation,request_id), UNIQUE(session_id,response_id)
-);
CREATE TABLE IF NOT EXISTS code_deleted(id TEXT PRIMARY KEY NOT NULL);
"""
+ + "CREATE TABLE IF NOT EXISTS code_prompts"
+ + _PROMPT_COLUMNS
+ + ";"
+)
diff --git a/tests/application/test_code_sessions.py b/tests/application/test_code_sessions.py
index 836d0896..38792a56 100644
--- a/tests/application/test_code_sessions.py
+++ b/tests/application/test_code_sessions.py
@@ -10,6 +10,7 @@ from free_claude_code.application.code_sessions.models import (
CodeValidationError,
HarnessEvent,
ItemUpdate,
+ PromptRequest,
)
from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
from tests.code_sessions_support import FakeConnection, FakeHarness
@@ -874,6 +875,147 @@ async def test_two_answers_claim_one_native_prompt(code):
assert (await service.get_detail(session.id)).prompts[0].status == "resolved"
+async def test_prompt_arrival_has_one_durable_position_despite_repeated_native_item(
+ code,
+):
+ service, harness, directory = code
+ session = await session_for(code)
+ run = await service.send(
+ session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.text("turn-1", "shared-tool", "Before approval", kind="tool")
+ subscription, _ = await service.subscribe()
+ try:
+ for request_id in (1, 1, "1"):
+ prompt = PromptRequest(
+ request_id, "approval", {}, {}, "turn-1", "shared-tool"
+ )
+ connection.requests[request_id] = prompt
+ await connection.sink(
+ HarnessEvent(
+ connection.generation,
+ connection.thread_id,
+ "prompt",
+ turn_id="turn-1",
+ prompt=prompt,
+ )
+ )
+ detail = await service.get_detail(session.id)
+ entries = [item for item in detail.items if item.kind == "prompt"]
+ assert len(entries) == len(detail.prompts) == 2
+ assert [item.sequence for item in entries] == [3, 4]
+ assert {item.id for item in entries} == {prompt.id for prompt in detail.prompts}
+ events = subscription.__aiter__()
+ async with asyncio.timeout(2):
+ for _ in range(2):
+ event = await anext(events)
+ if event.event == "item.updated":
+ event = await anext(events)
+ assert event.event == "prompt.updated"
+ assert event.data["item"]["id"] == event.data["prompt"]["id"]
+ assert event.data["runs"][0]["id"] == run.id
+ for request_id in (1, "1"):
+ await connection.resolve(request_id)
+ await connection.text(
+ "turn-1", "shared-tool", "Complete output", kind="tool", complete=True
+ )
+ await connection.text("turn-1", "after", "After approvals", complete=True)
+ await connection.finish("turn-1")
+ await service.close()
+ restored = CodeService(
+ SQLiteCodeStore(directory / "code.db", directory / "code.lock"), harness
+ )
+ await restored.start()
+ try:
+ saved = await restored.get_detail(session.id)
+ assert [item for item in saved.items if item.kind == "prompt"] == entries
+ assert [item.sequence for item in saved.items] == [1, 2, 3, 4, 5]
+ assert all(prompt.status == "resolved" for prompt in saved.prompts)
+ await restored.send(
+ session.id,
+ new_id(),
+ saved.session.revision,
+ "Continue",
+ expected_epoch=restored.epoch,
+ )
+ await harness.wait_inputs(2)
+ await harness.connections[-1].finish("turn-2")
+ recovered = await restored.get_detail(session.id)
+ assert [
+ item for item in recovered.items if item.kind == "prompt"
+ ] == entries
+ assert (
+ len(
+ [
+ item
+ for item in recovered.items
+ if item.native_item_id == "shared-tool"
+ ]
+ )
+ == 1
+ )
+ finally:
+ await restored.close()
+ finally:
+ await subscription.aclose()
+
+
+async def test_active_prompt_outside_page_keeps_its_entry_run_and_older_cursor(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ run = await service.send(
+ session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch
+ )
+ await harness.started.wait()
+ connection = harness.connections[0]
+ await connection.prompt(0, turn_id=None)
+ prompt = (await service.get_detail(session.id)).prompts[0]
+ for index in range(55):
+ await connection.text("turn-1", str(index), f"Output {index}", complete=True)
+ await connection.finish("turn-1")
+ newest = await service.get_detail(session.id)
+ assert newest.next_before is not None
+ assert len(newest.items) == 51
+ assert newest.items[0].id == prompt.id
+ assert newest.items[0].run_id == run.id
+ assert newest.active_prompt_ids == (prompt.id,)
+ await connection.resolve(0)
+ resolved = await service.get_detail(session.id)
+ assert resolved.active_prompt_ids == () and resolved.prompts == ()
+ assert resolved.next_before == newest.next_before
+ older = await service.get_detail(session.id, before=newest.next_before)
+ assert older.prompts[0].id == prompt.id and older.prompts[0].status == "resolved"
+ by_id = {item.id: item for item in (*older.items, *newest.items)}
+ assert sorted(item.sequence for item in by_id.values()) == list(range(1, 58))
+
+
+async def test_prompt_during_thread_creation_has_a_saved_run_without_native_ids(code):
+ service, harness, _ = code
+ session = await session_for(code)
+ harness.creation_gate.clear()
+ run = await service.send(
+ session.id, new_id(), session.revision, "Start", expected_epoch=service.epoch
+ )
+ await harness.creating.wait()
+ connection = harness.connections[0]
+ try:
+ await connection.prompt(0, turn_id=None)
+ detail = await service.get_detail(session.id)
+ assert detail.run.native_turn_id is None
+ assert detail.items[-1].id == detail.prompts[0].id
+ assert detail.items[-1].run_id == run.id
+ assert detail.items[-1].sequence == 2
+ assert detail.prompts[0].native_turn_id is None
+ await connection.resolve(0)
+ finally:
+ harness.creation_gate.set()
+
+
@pytest.mark.asyncio
async def test_native_resolution_while_answer_is_waiting_never_resurrects_prompt(code):
service, harness, _ = code
diff --git a/tests/runtime/test_code_sessions_sqlite.py b/tests/runtime/test_code_sessions_sqlite.py
index 007e3c15..5dadbbef 100644
--- a/tests/runtime/test_code_sessions_sqlite.py
+++ b/tests/runtime/test_code_sessions_sqlite.py
@@ -1,8 +1,10 @@
import asyncio
+import json
import sqlite3
import threading
import uuid
from contextlib import closing
+from typing import Literal
import pytest
import pytest_asyncio
@@ -202,7 +204,10 @@ async def test_schema_rejects_second_active_run_and_cross_session_item_link(
@pytest.mark.asyncio
async def test_prompt_claim_and_settings_are_guarded_in_storage(store):
- session = await _session(store)
+ session, run = await _admit(store, await _session(store))
+ await store.save_progress(
+ session, session.revision, run=run.model_copy(update={"status": "completed"})
+ )
prompts = tuple(
CodePrompt(
id=str(uuid.uuid4()),
@@ -215,7 +220,18 @@ async def test_prompt_claim_and_settings_are_guarded_in_storage(store):
)
for request_id in (1, "1")
)
- await store.save_progress(session, session.revision, prompts=prompts)
+ items = tuple(
+ CodeItem(
+ id=prompt.id,
+ session_id=session.id,
+ run_id=run.id,
+ sequence=index + 2,
+ kind="prompt",
+ complete=True,
+ )
+ for index, prompt in enumerate(prompts)
+ )
+ await store.save_progress(session, session.revision, items=items, prompts=prompts)
results = await asyncio.gather(
*(
store.claim_prompt(session.id, prompts[0].id, str(uuid.uuid4()), "g")
@@ -275,3 +291,228 @@ async def test_recovered_old_output_pages_with_its_original_run_outcome(store):
assert page.next_before == (old.ordinal, 3)
older = await store.item_page(session.id, page.next_before, 2)
assert [item.sequence for item in older.items] == [1]
+
+
+async def test_prompt_entry_and_form_are_atomic_and_linked_in_storage(store, tmp_path):
+ session, run = await _admit(store, await _session(store))
+ prompt = CodePrompt(
+ id=str(uuid.uuid4()),
+ session_id=session.id,
+ generation="g",
+ request_id=1,
+ kind="questions",
+ form={},
+ raw={},
+ )
+ item = CodeItem(
+ id=prompt.id,
+ session_id=session.id,
+ run_id=run.id,
+ sequence=2,
+ kind="prompt",
+ complete=True,
+ )
+ with pytest.raises(CodeConflictError):
+ await store.save_progress(session, session.revision, prompts=(prompt,))
+ with pytest.raises(CodeConflictError):
+ await store.save_progress(
+ session,
+ session.revision,
+ items=(item.model_copy(update={"kind": "text"}),),
+ prompts=(prompt,),
+ )
+ assert await store.prompts(session.id) == ()
+ assert len(await store.items(session.id, None, None)) == 1
+ await store.save_progress(
+ session, session.revision, items=(item,), prompts=(prompt,)
+ )
+ other = await _session(store)
+ with closing(sqlite3.connect(tmp_path / "code.db")) as connection:
+ connection.execute("PRAGMA foreign_keys = ON")
+ with pytest.raises(sqlite3.IntegrityError):
+ connection.execute("UPDATE code_prompts SET session_id = ?", (other.id,))
+ connection.rollback()
+ with pytest.raises(sqlite3.IntegrityError):
+ connection.execute("UPDATE code_prompts SET id = 'unlinked'")
+ assert await store.prompts(session.id) == (prompt,)
+
+
+_LEGACY_PROMPTS = """
+CREATE TABLE code_prompts(
+ session_id TEXT NOT NULL REFERENCES code_sessions(id) ON DELETE CASCADE,
+ id TEXT NOT NULL, generation TEXT NOT NULL, request_id TEXT NOT NULL,
+ native_turn_id TEXT, native_item_id TEXT, kind TEXT NOT NULL,
+ form TEXT NOT NULL, raw TEXT NOT NULL,
+ status TEXT NOT NULL CHECK(status IN ('pending','answering','resolved','expired')),
+ response_id TEXT, error TEXT,
+ PRIMARY KEY(session_id,id), UNIQUE(session_id,generation,request_id),
+ UNIQUE(session_id,response_id)
+)
+"""
+
+
+async def _legacy_prompt_database(store, path):
+ session, old = await _admit(store, await _session(store))
+ await store.save_progress(
+ session,
+ session.revision,
+ run=old.model_copy(
+ update={
+ "native_turn_id": "old-turn",
+ "submission_started": True,
+ "status": "completed",
+ }
+ ),
+ )
+ tool = CodeItem(
+ id=str(uuid.uuid4()),
+ session_id=session.id,
+ run_id=old.id,
+ sequence=2,
+ native_turn_id="old-turn",
+ native_item_id="shared-tool",
+ kind="tool",
+ text="Original tool output",
+ complete=True,
+ )
+ await store.save_progress(session, session.revision, items=(tool,))
+ session, latest = await _admit(store, session, text="Later turn", sequence=3)
+ await store.save_progress(
+ session,
+ session.revision,
+ run=latest.model_copy(
+ update={
+ "status": "completed",
+ }
+ ),
+ )
+ original = await store.items(session.id, None, None)
+ await store.close()
+ cases: list[
+ tuple[str | None, str | None, Literal["resolved", "expired", "pending"]]
+ ] = [
+ ("old-turn", None, "resolved"),
+ (None, "shared-tool", "expired"),
+ (None, None, "resolved"),
+ ("missing-turn", None, "pending"),
+ ("old-turn", None, "expired"),
+ ]
+ prompts = tuple(
+ CodePrompt(
+ id=str(uuid.uuid4()),
+ session_id=session.id,
+ generation="g",
+ request_id=index,
+ native_turn_id=turn,
+ native_item_id=item,
+ kind="questions",
+ form={"title": "Old question"},
+ raw={"keep": "native payload"},
+ status=status,
+ response_id=str(uuid.uuid4()) if status == "resolved" else None,
+ )
+ for index, (turn, item, status) in enumerate(cases)
+ )
+ with closing(sqlite3.connect(path)) as connection, connection:
+ connection.execute("DROP TABLE code_prompts")
+ connection.execute(_LEGACY_PROMPTS)
+ connection.execute("PRAGMA user_version = 0")
+ for prompt in prompts:
+ connection.execute(
+ "INSERT INTO code_prompts VALUES (?,?,?,?,?,?,?,?,?,?,?,?)",
+ (
+ session.id,
+ prompt.id,
+ prompt.generation,
+ json.dumps(prompt.request_id),
+ prompt.native_turn_id,
+ prompt.native_item_id,
+ prompt.kind,
+ json.dumps(prompt.form),
+ json.dumps(prompt.raw),
+ prompt.status,
+ prompt.response_id,
+ prompt.error,
+ ),
+ )
+ return session, old, latest, original, prompts
+
+
+async def test_legacy_prompts_migrate_once_to_run_ends_without_resequencing(
+ store, tmp_path
+):
+ path = tmp_path / "code.db"
+ session, old, latest, original, prompts = await _legacy_prompt_database(store, path)
+ for _ in range(2):
+ await store.start()
+ items = await store.items(session.id, None, None)
+ assert [item.id for item in items] == [
+ original[0].id,
+ original[1].id,
+ prompts[0].id,
+ prompts[1].id,
+ prompts[4].id,
+ original[2].id,
+ prompts[2].id,
+ prompts[3].id,
+ ]
+ assert [item for item in items if item.kind != "prompt"] == list(original)
+ entries = {item.id: item for item in items if item.kind == "prompt"}
+ for index, prompt in enumerate(prompts):
+ entry = entries[prompt.id]
+ assert entry.run_id == (old.id if index in (0, 1, 4) else latest.id)
+ assert entry.sequence == len(original) + index + 1
+ assert entry.native_item_id is None and entry.native_turn_id is None
+ assert entry.raw == {} and entry.text == ""
+ saved = {prompt.id: prompt for prompt in await store.prompts(session.id)}
+ for prompt in prompts:
+ expected = (
+ prompt.model_copy(update={"status": "expired"})
+ if prompt.status == "pending"
+ else prompt
+ )
+ assert saved[prompt.id] == expected
+ with closing(sqlite3.connect(path)) as connection:
+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 1
+ assert connection.execute("PRAGMA foreign_key_check").fetchall() == []
+ assert any(
+ row[2] == "code_items"
+ for row in connection.execute("PRAGMA foreign_key_list(code_prompts)")
+ )
+ await store.close()
+
+
+async def test_failed_prompt_migration_rolls_back_items_schema_and_version(
+ store, tmp_path
+):
+ path = tmp_path / "code.db"
+ _, _, _, original, prompts = await _legacy_prompt_database(store, path)
+ with closing(sqlite3.connect(path)) as connection, connection:
+ connection.execute(
+ "CREATE TRIGGER refuse_second_prompt BEFORE INSERT ON code_items "
+ "WHEN NEW.id = '"
+ + prompts[1].id
+ + "' BEGIN SELECT RAISE(ABORT, 'blocked'); END"
+ )
+ with pytest.raises(CodeConflictError):
+ await store.start()
+ with closing(sqlite3.connect(path)) as connection, connection:
+ assert connection.execute("PRAGMA user_version").fetchone()[0] == 0
+ assert connection.execute("SELECT count(*) FROM code_items").fetchone()[
+ 0
+ ] == len(original)
+ assert connection.execute("SELECT count(*) FROM code_prompts").fetchone()[
+ 0
+ ] == len(prompts)
+ assert not any(
+ row[2] == "code_items"
+ for row in connection.execute("PRAGMA foreign_key_list(code_prompts)")
+ )
+ connection.execute("DROP TRIGGER refuse_second_prompt")
+ await store.start()
+ assert len(await store.items(prompts[0].session_id, None, None)) == len(
+ original
+ ) + len(prompts)