Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
Record which coworker a person chose on /channel/new, not only in the home composer (#342)
kevin9505c42eb8c5
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 7763f1eb..91961f70 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,12 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.## Unreleased+### A conversation started from the sidebar is recorded like one started from the home screen++The trail had a `channel.routed` row for every conversation begun in the home composer — the+coworker it went to and why, whether inferred or named with `@` — and nothing at all for one begun+from the sidebar's +, a coworker's card or its profile, which read exactly like a row that failed+to write. Picking a coworker in that To: field is now recorded the same way an `@` is.### A browser clock that runs ahead no longer hides what a routine saidThe roster line and unread dot for a channel are moved by the last report that arrived, and onlydiff --git a/app/src/lib/channels/start.ts b/app/src/lib/channels/start.tsindex de2c2551..4d3a6d23 100644--- a/app/src/lib/channels/start.ts+++ b/app/src/lib/channels/start.ts@@ -3,6 +3,31 @@ import { useNavigate } from "@tanstack/react-router";import { stashFirstMessage } from "@/components/channels/transcript-messages";import { createChannelMutationOptions } from "./mutations";import { channelKeys } from "./queries";+import { routeMessage } from "./route";++/**+ * Start a channel with a coworker the person chose themselves, and say so first.+ *+ * A conversation that was routed has a `channel.routed` row saying where it went and why; one whose+ * coworker the person picked must have one too, or the trail reads as if the row failed to write.+ * The home composer told the server about an `@` choice; a coworker picked in the To: field of+ * `/channel/new` — the sidebar's +, a coworker's card, its profile — was never told to anybody. The+ * two screens now share this one sequence: record, then start.+ *+ * The record is told before the channel exists, the way the routed path records before a channel is+ * pinned, and its answer is thrown away: the person already decided and nothing here may change+ * that. Failing to write the row must not stop the conversation, so a rejection is swallowed whole.+ * Pure so the sequence can be tested; the hook below binds it to the real calls.+ */+export async function startWithChosen(input: {+ agentId: string;+ text: string;+ record: (text: string, agentId: string) => Promise<unknown>;+ start: (agentId: string, text: string) => Promise<void>;+}): Promise<void> {+ await input.record(input.text, input.agentId).catch(() => undefined);+ await input.start(input.agentId, input.text);+}/*** Start a channel from a just-submitted first message, then navigate there.@@ -15,17 +40,22 @@ export function useStartChannel() {const navigate = useNavigate();const createChannel = useMutation(createChannelMutationOptions(queryClient));+ const start = async (agentId: string, text: string) => {+ const channel = await createChannel.mutateAsync([agentId]);+ queryClient.setQueryData(channelKeys.detail(channel.id), channel);+ stashFirstMessage(channel.id, text);+ await navigate({+ params: { channelId: channel.id },+ replace: true,+ to: "/channel/$channelId",+ });+ };+return {pending: createChannel.isPending,- start: async (agentId: string, text: string) => {- const channel = await createChannel.mutateAsync([agentId]);- queryClient.setQueryData(channelKeys.detail(channel.id), channel);- stashFirstMessage(channel.id, text);- await navigate({- params: { channelId: channel.id },- replace: true,- to: "/channel/$channelId",- });- },+ start,+ /** `start`, for a coworker the person chose: the choice is recorded first. */+ startChosen: (agentId: string, text: string) =>+ startWithChosen({ agentId, text, record: routeMessage, start }),};}diff --git a/app/src/routes/_authed/_app/channel/new.tsx b/app/src/routes/_authed/_app/channel/new.tsxindex c4ab4346..6299e51e 100644--- a/app/src/routes/_authed/_app/channel/new.tsx+++ b/app/src/routes/_authed/_app/channel/new.tsx@@ -38,7 +38,7 @@ export const Route = createFileRoute("/_authed/_app/channel/new")({function RouteComponent() {const { agent } = Route.useSearch();const navigate = Route.useNavigate();- const { start, pending } = useStartChannel();+ const { startChosen, pending } = useStartChannel();const { data: profiles } = useQuery(agentListQueryOptions());const [error, setError] = useState<string | null>(null);@@ -135,7 +135,9 @@ function RouteComponent() {setSent(seedMessage(draft.text, newId()));try {- await start(recipient.id, draft.text);+ // Recorded, then started: a coworker picked here is as much a choice as an `@` on the+ // home screen, and the trail has to say so for both.+ await startChosen(recipient.id, draft.text);} catch (caught) {// Preserve the unsent draft when channel creation fails.setSent(null);diff --git a/app/src/routes/_authed/_app/index.tsx b/app/src/routes/_authed/_app/index.tsxindex 623d3423..bf3952a6 100644--- a/app/src/routes/_authed/_app/index.tsx+++ b/app/src/routes/_authed/_app/index.tsx@@ -16,7 +16,7 @@ export const Route = createFileRoute("/_authed/_app/")({function RouteComponent() {const { data: agents } = useQuery(agentListQueryOptions());const explore = agents?.filter((a) => !a.mine && a.visibility === "public");- const { start, pending } = useStartChannel();+ const { start, startChosen, pending } = useStartChannel();const [error, setError] = useState<string | null>(null);/** Default recipient when the composer draft has no mention. */@@ -46,22 +46,17 @@ function RouteComponent() {// run, it falls back to the same default the composer used to always use.setError(null);try {- let agentId: string | undefined = draft.agentId ?? undefined;- if (agentId) {- /*- * Told to the server so the choice is recorded, and its answer thrown away: the- * person already decided and nothing here may change that. Failing to write the- * audit row must not stop the conversation, so a rejection is swallowed whole.- */- await routeMessage(draft.text, agentId).catch(- () => undefined,- );- } else {- try {- agentId = (await routeMessage(draft.text)).agentId;- } catch {- agentId = fallback?.id;- }+ if (draft.agentId) {+ // Recorded and started as one sequence, shared with `/channel/new`: the person+ // already decided, and the trail has to say so wherever they decided it.+ await startChosen(draft.agentId, draft.text);+ return;+ }+ let agentId: string | undefined;+ try {+ agentId = (await routeMessage(draft.text)).agentId;+ } catch {+ agentId = fallback?.id;}if (!agentId) return;await start(agentId, draft.text);diff --git a/app/tests/start-chosen.test.ts b/app/tests/start-chosen.test.tsnew file mode 100644index 00000000..a7304399--- /dev/null+++ b/app/tests/start-chosen.test.ts@@ -0,0 +1,85 @@+import { expect, test } from "bun:test";+import { startWithChosen } from "../src/lib/channels/start";++/**+ * A conversation whose coworker the person picked themselves has to reach the trail the same way a+ * routed one does. `/channel/new` — the sidebar's +, a coworker's card, its profile — started the+ * channel and told nobody; the home composer told the server about an `@`. Both now run this one+ * sequence, so what it does is what the trail sees.+ */++function harness(record: (text: string, agentId: string) => Promise<unknown>) {+ const calls: string[] = [];+ return {+ calls,+ record: (text: string, agentId: string) => {+ calls.push(`record ${agentId} ${text}`);+ return record(text, agentId);+ },+ start: async (agentId: string, text: string) => {+ calls.push(`start ${agentId} ${text}`);+ },+ };+}++test("tells the server the choice before the channel is made", async () => {+ const { calls, record, start } = harness(async () => ({+ agentId: "risk-analyst",+ }));++ await startWithChosen({+ agentId: "risk-analyst",+ text: "hello",+ record,+ start,+ });++ expect(calls).toEqual([+ "record risk-analyst hello",+ "start risk-analyst hello",+ ]);+});++test("a record that fails to write does not stop the conversation", async () => {+ const { calls, record, start } = harness(async () => {+ throw new Error("Could not choose a coworker.");+ });++ await startWithChosen({+ agentId: "risk-analyst",+ text: "hello",+ record,+ start,+ });++ expect(calls).toEqual([+ "record risk-analyst hello",+ "start risk-analyst hello",+ ]);+});++test("the server's answer cannot change who the person chose", async () => {+ const { calls, record, start } = harness(async () => ({+ agentId: "somebody-else",+ }));++ await startWithChosen({+ agentId: "risk-analyst",+ text: "hello",+ record,+ start,+ });++ expect(calls[1]).toBe("start risk-analyst hello");+});++test("a channel that cannot be started still fails the send", async () => {+ const { record } = harness(async () => undefined);+ const start = async () => {+ throw new Error("Could not start a channel");+ };++ await expect(+ startWithChosen({ agentId: "risk-analyst", text: "hello", record, start }),+ ).rejects.toThrow("Could not start a channel");+});