Skip to content

A personal agent with a browser, terminal, files, and work that keeps going built with CopilotKit and AG-UI.

TypeScript

fix: cancel delegated browser observations with task execution (#31)

Kevin Rajanec443e61b523
diff --git a/apps/server/src/browser.ts b/apps/server/src/browser.ts
index c55b2a6..7802eca 100644
--- a/apps/server/src/browser.ts
+++ b/apps/server/src/browser.ts
@@ -125,7 +125,7 @@ export class BrowserService {
await this.db.put(owner, "browsers", session);
return this.decorate(owner, session);
}
- async create(owner: string, url: string) {
+ async create(owner: string, url: string, signal?: AbortSignal) {
const id = randomUUID();
// Record ownership before calling the worker, including when its response is lost.
await this.db.put(owner, "browsers", {
@@ -135,7 +135,7 @@ export class BrowserService {
status: "idle",
updatedAt: new Date().toISOString(),
});
- return this.reopen(owner, id, url);
+ return this.reopen(owner, id, url, signal);
}
private async openOwned(owner: string, id: string, url?: string, signal?: AbortSignal) {
const value = await this.get(owner, id);
@@ -144,6 +144,7 @@ export class BrowserService {
const response = await this.request("/sessions", { id, url: target }, signal);
return await this.save(owner, await response.json(), id);
} catch (error) {
+ signal?.throwIfAborted();
await this.save(
owner,
{ ...value, url: target, status: "error", updatedAt: new Date().toISOString() },
@@ -152,8 +153,8 @@ export class BrowserService {
throw error;
}
}
- reopen(owner: string, id: string, url?: string) {
- return this.serial(id, () => this.openOwned(owner, id, url));
+ reopen(owner: string, id: string, url?: string, signal?: AbortSignal) {
+ return this.serial(id, () => this.openOwned(owner, id, url, signal));
}
navigate(owner: string, id: string, url: string) {
return this.reopen(owner, id, url);
@@ -181,11 +182,13 @@ export class BrowserService {
read(owner: string, id: string) {
return this.serial(id, () => this.readOwned(owner, id));
}
- async observe(owner: string, url: string, existingId?: string) {
- const id = existingId ?? (await this.create(owner, url)).id;
+ async observe(owner: string, url: string, existingId?: string, signal?: AbortSignal) {
+ const id = existingId ?? (await this.create(owner, url, signal)).id;
return this.serial(id, async () => {
- if (existingId) await this.openOwned(owner, id, url);
- return { sessionId: id, ...(await this.readOwned(owner, id)) };
+ signal?.throwIfAborted();
+ if (existingId) await this.openOwned(owner, id, url, signal);
+ signal?.throwIfAborted();
+ return { sessionId: id, ...(await this.readOwned(owner, id, signal)) };
});
}
async observeForThread(owner: string, threadId: string, url: string, signal?: AbortSignal) {
diff --git a/apps/server/src/engine/model.ts b/apps/server/src/engine/model.ts
index f100a57..8102fcf 100644
--- a/apps/server/src/engine/model.ts
+++ b/apps/server/src/engine/model.ts
@@ -199,6 +199,7 @@ export async function executeModelTask(
owner,
url,
typeof task.state.browserId === "string" ? task.state.browserId : undefined,
+ ctx.signal,
);
task = await ctx.checkpoint({
state: { ...task.state, browserId: page.sessionId },
diff --git a/apps/server/src/engine/service.ts b/apps/server/src/engine/service.ts
index 8cafc36..0367a35 100644
--- a/apps/server/src/engine/service.ts
+++ b/apps/server/src/engine/service.ts
@@ -1047,6 +1047,7 @@ export class AgentService {
owner,
monitor.url,
typeof task.state.sessionId === "string" ? task.state.sessionId : undefined,
+ ctx.signal,
);
}
const text = observation.text.replace(/\s+/g, " ").trim();
diff --git a/tests/browser.test.ts b/tests/browser.test.ts
index 7308ae0..cb386c7 100644
--- a/tests/browser.test.ts
+++ b/tests/browser.test.ts
@@ -158,6 +158,22 @@ test("browser observations reuse an owned profile and reject unowned reads", asy
assert.equal(fresh.text, read.text);
});
+test("cancelled task-style browser observations stop before a follow-up read", async (t) => {
+ const controller = new AbortController();
+ const calls: string[] = [];
+ const { db, service } = await browserFixture(t, (path, body) => {
+ calls.push(path);
+ controller.abort();
+ return { data: { ...savedSession, id: body.id, url: body.url } };
+ });
+ await assert.rejects(service.observe("owner", savedSession.url, undefined, controller.signal), {
+ name: "AbortError",
+ });
+ assert.deepEqual(calls, ["/sessions"]);
+ const [saved] = await db.list<BrowserSession>("owner", "browsers");
+ assert.equal(saved?.status, "idle", "cancellation must not persist a browser failure");
+});
+
test("chat browser reads reuse a persisted owned profile across turns and service restarts", async (t) => {
const calls: { path: string; body: Record<string, unknown> }[] = [];
let currentUrl = savedSession.url;
diff --git a/tests/model-worker.test.ts b/tests/model-worker.test.ts
index b4e566c..cbaa4b8 100644
--- a/tests/model-worker.test.ts
+++ b/tests/model-worker.test.ts
@@ -1,5 +1,7 @@
import assert from "node:assert/strict";
+import { once } from "node:events";
import { mkdtemp, rm } from "node:fs/promises";
+import { createServer } from "node:http";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { test } from "node:test";
@@ -291,3 +293,76 @@ test("browser reads keep observation identity distinct while reusing one session
assert.equal(sessionIds.size, 1, "both reads should reuse the same browser session");
assert.equal(new Set(webEvidence.map((item) => item.id)).size, 2);
});
+
+test("aborting delegated read_web stops before page read and requeues the task", async (t) => {
+ const directory = await mkdtemp(join(tmpdir(), "openmuse-model-browser-abort-"));
+ const db = await createStore();
+ const browserCalls: string[] = [];
+ let resolveNavigation!: () => void;
+ const navigationStarted = new Promise<void>((resolve) => {
+ resolveNavigation = resolve;
+ });
+ const browserWorker = createServer(async (request, response) => {
+ for await (const _chunk of request) {
+ // Drain the request body before holding the navigation response open.
+ }
+ const path = request.url ?? "";
+ browserCalls.push(path);
+ if (path === "/sessions") {
+ resolveNavigation();
+ return;
+ }
+ response.writeHead(200, { "content-type": "application/json" });
+ response.end(
+ JSON.stringify({
+ url: "https://example.org/",
+ title: "Observed",
+ text: "This read must never happen after abort.",
+ truncated: false,
+ }),
+ );
+ });
+ browserWorker.listen(0, "127.0.0.1");
+ await once(browserWorker, "listening");
+ const address = browserWorker.address();
+ assert.ok(address && typeof address !== "string");
+
+ await modelFixture(t, (index) =>
+ index === 0 ? { name: "read_web", arguments: { url: "https://example.org/" } } : undefined,
+ );
+ const server = await createApp(db, {
+ mode: "sample",
+ port: 8787,
+ host: "127.0.0.1",
+ publicUrl: "http://localhost:8787",
+ dataDir: directory,
+ agentBackend: "model",
+ intelligenceApiKey: "test-project-key-never-sent",
+ model: "openai/fixture",
+ googleRedirectUri: "http://localhost:8787/api/google/callback",
+ allowedOrigins: [],
+ workerUrl: `http://127.0.0.1:${address.port}`,
+ workerToken: "test-worker-token-at-least-32-characters",
+ });
+
+ try {
+ const task = await server.agent.createTask("owner", {
+ prompt: "Read the example page and summarize it",
+ });
+ const tick = server.agent.worker.tick();
+ await navigationStarted;
+ server.agent.worker.abort(task.id);
+ await tick;
+
+ const settled = await server.agent.getTask("owner", task.id);
+ assert.equal(settled.status, "queued", settled.error ?? settled.result);
+ assert.equal(settled.error, undefined);
+ assert.deepEqual(browserCalls, ["/sessions"]);
+ } finally {
+ await server.agent.stop();
+ browserWorker.closeAllConnections();
+ await new Promise<void>((resolve) => browserWorker.close(() => resolve()));
+ await db.close();
+ await rm(directory, { recursive: true, force: true });
+ }
+});