Skip to content

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.

Offer a conversation to be named only when the queue holds nothing for it (#587)

kevind2b731938799
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 61d04f50..91b0bf82 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,15 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.
## Unreleased
+### New conversations are still named once some older ones could not be
+
+Every pass of the job that names conversations offered at most twenty of those still without a name.
+A conversation it had tried and could not name, for example because the model answered with no text
+or the conversation opened with only an attachment, keeps no name, so it stayed among those twenty
+and took a place on every pass, although offering it again did nothing. Once enough of them had built
+up, a new conversation could miss out on every pass and keep showing its plain name in the sidebar.
+A pass now skips any conversation that the job already holds work for, so new ones get a place. One
+it could not name is still tried again later, as before.
### An offboarding one app refuses still records the apps that answered
Removing somebody withdraws each brokered account they connected. When the broker refused one of
diff --git a/server/src/channels/summary.ts b/server/src/channels/summary.ts
index 3686ab2b..c1a46424 100644
--- a/server/src/channels/summary.ts
+++ b/server/src/channels/summary.ts
@@ -7,13 +7,14 @@
* Offer then claim, like `work/culler.ts`. The offer is derived from the table rather than from an
* event, so a missed sweep costs two seconds where a missed event would cost the name entirely.
*/
-import { and, asc, eq, isNull, sql } from "drizzle-orm";
+import { and, asc, eq, isNull, notExists, sql } from "drizzle-orm";
import { readFiring } from "../../../shared/routine-firing";
import type { Database } from "../db/client";
import {
channelMemberships,
channels,
intelligenceChannelMappings,
+ workItems,
} from "../db/schema";
import { DEFAULT_MAX_ATTEMPTS, type WorkQueue } from "../work/queue";
import { CHANNEL_ACTIVITY_TOPIC, type ChannelActivityEvent } from "./events";
@@ -73,6 +74,25 @@ export async function offerChannelsAwaitingSummary(
isNull(channels.summary),
isNull(channels.deletedAt),
sql`${channels.lastMessageAt} is not null`,
+ /*
+ * Not one the queue already holds a row for, pending or settled.
+ *
+ * Offering it again changes nothing, but it takes one of the `limit` places. A conversation
+ * this cannot name keeps no summary and so never leaves the set above, and enough of them
+ * ahead of a new conversation left the new one unoffered on every pass. Once its settled row
+ * is forgotten it is offered again, as before.
+ */
+ notExists(
+ options.database
+ .select({ key: workItems.key })
+ .from(workItems)
+ .where(
+ and(
+ eq(workItems.kind, CHANNEL_SUMMARY_KIND),
+ eq(workItems.key, channels.id),
+ ),
+ ),
+ ),
),
)
.limit(options.limit ?? 20);
diff --git a/server/tests/channel-summary.integration.test.ts b/server/tests/channel-summary.integration.test.ts
index 83724a6e..ab6ac951 100644
--- a/server/tests/channel-summary.integration.test.ts
+++ b/server/tests/channel-summary.integration.test.ts
@@ -195,6 +195,46 @@ describe("offering conversations to be named", () => {
.where(eq(workItems.key, channel.id));
expect(rows).toHaveLength(1);
});
+
+ /*
+ * A pass offers at most `limit` conversations, twenty by default, and a conversation it could not
+ * name keeps no summary, so it stays in the set the pass reads. Offering it again while its settled
+ * work row stands does nothing, but it still used one of those places. Twenty such conversations
+ * ahead of a new one left nothing for it, pass after pass.
+ */
+ test("does not spend a place on a conversation whose settled work still stands", async () => {
+ const owner = await createUser();
+ const channel = await createUsedChannel(owner);
+ await offer(channel.id);
+ // Settled without a name, the way a model that answers with nothing leaves it.
+ await summariseClaimedChannels(options({ title: titler(null) }));
+ expect((await summaryOf(channel.id))?.summary).toBeNull();
+
+ const { offered } = await offerChannelsAwaitingSummary({
+ database,
+ queue,
+ limit: 200,
+ });
+
+ expect(offered).not.toContain(channel.id);
+ });
+
+ test("offers it again once its settled work has been forgotten", async () => {
+ const owner = await createUser();
+ const channel = await createUsedChannel(owner);
+ await offer(channel.id);
+ await summariseClaimedChannels(options({ title: titler(null) }));
+ // What `forgetSettledSummaries` does once the finished row is an hour old.
+ await database.delete(workItems).where(eq(workItems.key, channel.id));
+
+ const { offered } = await offerChannelsAwaitingSummary({
+ database,
+ queue,
+ limit: 200,
+ });
+
+ expect(offered).toContain(channel.id);
+ });
});
/**