Skip to content

armgit / qm

Public Imported from GitHub
0

Multiplayer agent harness for work.

Assign session titles before turn setup (#2162)

Regan Bell5a3cff29a97e
diff --git a/src/core/orchestrator.ts b/src/core/orchestrator.ts
index 744218cae..7410f4b78 100644
--- a/src/core/orchestrator.ts
+++ b/src/core/orchestrator.ts
@@ -166,13 +166,12 @@ import {
} from "../harness/replay.ts";
import { errMessage, reportFailure, swallow, swallowAs } from "../util/errors.ts";
import { isObj } from "../util/objects.ts";
-import { absoluteAppLinks, headSlice, jsonbSafeStringify } from "../util/text.ts";
+import { absoluteAppLinks, jsonbSafeStringify } from "../util/text.ts";
import {
isModelBudget,
isNonRetryable,
NonRetryableTurnError,
ProviderTurnError,
- TitleRejected,
turnFailureMessage,
type TurnFailurePayload,
} from "./turn-error.ts";
@@ -187,6 +186,7 @@ import { isHarnessId, CODEX_SUBSCRIPTION_PROVIDER } from "../model/pi-models.ts"
import type { ProviderKeys } from "../harness/pi-harness.ts";
import type { CodexTurnAuth } from "../harness/harness.ts";
import { resolveIndividualAuthRouting } from "./individual-auth-routing.ts";
+import { createSessionTitles } from "./session-title.ts";
import {
MAX_AUTO_ATTACHMENT_SCREEN_BYTES,
approvalGrantId,
@@ -202,7 +202,6 @@ import {
renderTitleTranscript,
replayableRequest,
stripAckPrefix,
- stripTurnBoilerplate,
turnPostKeys,
visibleTitleEntryText,
} from "./orchestrator/turn-helpers.ts";
@@ -340,42 +339,12 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
const classifySecurityData = createSecurityClassifier(deps);
- function fallbackSessionTitle(text: string): string | undefined {
- const clean = stripTurnBoilerplate(text).replace(/\s+/g, " ").trim();
- if (!clean) return undefined;
- return clean.length > 60 ? `${headSlice(clean, 59).trimEnd()}…` : clean;
- }
-
- async function generateAndStoreTitle(
- sessionId: string,
- scopeId: ScopeId,
- transcript: string,
- principalId?: string,
- fallbackText?: string,
- ): Promise<string | undefined> {
- if (!transcript.trim()) return undefined;
- let title: string | undefined;
- try {
- title = await deps.harness.models.generateTitle?.(transcript);
- } catch (e) {
- deps.errors?.record(
- {
- category: "session_title",
- code: e instanceof TitleRejected ? `rejected_${e.rule}` : "generation_failed",
- message: errMessage(e),
- scopeLabel: scopeId,
- sessionId,
- },
- e,
- );
- }
- title ??= fallbackText ? fallbackSessionTitle(fallbackText) : undefined;
- if (title) {
- if (principalId) await deps.sessions.updateParticipantView(sessionId, principalId, { title });
- else await deps.sessions.updateTitle(sessionId, title);
- }
- return title;
- }
+ const titles = createSessionTitles({
+ sessions: deps.sessions,
+ harness: deps.harness,
+ ...(deps.sessionStateBus ? { sessionStateBus: deps.sessionStateBus } : {}),
+ ...(deps.errors ? { errors: deps.errors } : {}),
+ });
function recordSessionBusy(busy: {
site: "turn" | "quarantined_input" | "flagged_input";
@@ -547,7 +516,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
if (entries.length === 0) return null;
const transcript = renderTitleTranscript(entries);
const fallbackEntry = entries.find((entry) => entry.type === "user" && !isOverheardEntry(entry));
- const title = await generateAndStoreTitle(
+ const title = await titles.generateAndStore(
session.id,
session.scopeId,
transcript,
@@ -1378,6 +1347,16 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
if (!input.sessionParticipantIds?.length && !automatedTurn)
await deps.sessions.addParticipant(session.id, actor.id);
+ const delegatedTask =
+ automatedTurn && !!input.sessionSenderId && session.parentSessionId === input.sessionSenderId;
+ const syntheticInput = (input.proactiveOpener && !input.text.trim()) || (automatedTurn && !delegatedTask);
+ const titleText = input.displayText?.trim() || input.text;
+ let fallbackTitleWrite: Promise<void> | undefined;
+ const assignSessionTitle = () => {
+ if (!session.title && !syntheticInput && !input.approval)
+ fallbackTitleWrite = titles.titleFromFirstMessage(session, scopeId, titleText);
+ };
+
const isRetry = (input.attempt ?? 1) > 1;
const recordedTurnForRun = async (): Promise<RecordedTurn | null> => {
if (!input.runId || !deps.runs) return null;
@@ -2112,6 +2091,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
leaseMs += Date.now() - leaseStart - acquired.waitedMs;
if (!acquired.lease) return acquired.refusal;
const lease = acquired.lease;
+ if (!ambientTurn) assignSessionTitle();
const trackRevisions = input.surface === "slack" && Boolean(deps.surfaceCache);
const revisionAnchor = trackRevisions ? await revisionAnchorAt(deps.sessions, session.id) : undefined;
const catchUpMessageRevisions = async (): Promise<void> => {
@@ -2594,6 +2574,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
: { status: "silent", sessionId: session.id };
}
}
+ if (ambientTurn) assignSessionTitle();
if (input.runId) {
if ((input.surface === "slack" || input.surface === "monitor") && input.runLeaseToken) {
@@ -3344,14 +3325,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
let firstChunkAt: number | undefined;
let lastChunkAt: number | undefined;
const emittedEntries: SessionEntry[] = [];
- const delegatedTask =
- automatedTurn && !!input.sessionSenderId && session.parentSessionId === input.sessionSenderId;
- const syntheticPrompt =
- (input.proactiveOpener && !input.text.trim()) ||
- (automatedTurn && !delegatedTask) ||
- partial ||
- approvalReplay ||
- !!releasedToolOutput;
+ const syntheticPrompt = syntheticInput || partial || approvalReplay || !!releasedToolOutput;
failureUserPayload =
!syntheticPrompt && input.text.trim()
? {
@@ -3361,15 +3335,6 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
...(input.displayText?.trim() ? { display: input.displayText } : {}),
}
: undefined;
- const titleText = input.displayText?.trim() || input.text;
- const fallbackTitle = !session.title && !syntheticPrompt ? fallbackSessionTitle(titleText) : undefined;
- const fallbackTitleWrite = fallbackTitle ? deps.sessions.updateTitle(session.id, fallbackTitle) : undefined;
- if (fallbackTitleWrite && deps.harness.models.generateTitle) {
- void fallbackTitleWrite
- .then(() => generateAndStoreTitle(session.id, scopeId, `User:\n${stripTurnBoilerplate(titleText)}`))
- .finally(() => deps.errors?.flush())
- .catch(swallowAs("orchestrator: session title", undefined));
- }
const requestedTurnWallClockMs =
typeof input.turnWallClockMs === "number" && input.turnWallClockMs > 0 ? input.turnWallClockMs : undefined;
const configuredTurnWallClockSec = await deps.config?.getTurnWallClockSecDurable(resolution.orgScopeId);
@@ -4410,7 +4375,7 @@ export function createOrchestrator(deps: OrchestratorDeps): Orchestrator {
}
}
if (!pausing && turnCompleted && !session.title && !fallbackTitleWrite) {
- await generateAndStoreTitle(session.id, scopeId, `User:\n${titleText}\n\nAssistant:\n${result.reply}`);
+ await titles.generateAndStore(session.id, scopeId, `User:\n${titleText}\n\nAssistant:\n${result.reply}`);
}
} finally {
await reclaimBox();
diff --git a/src/core/orchestrator/types.ts b/src/core/orchestrator/types.ts
index 3f5aadd83..0891a82d7 100644
--- a/src/core/orchestrator/types.ts
+++ b/src/core/orchestrator/types.ts
@@ -21,6 +21,7 @@ import type { IsCurrentSharedScopeMember, ManagedGroupDirectory } from "../../re
import type { DirectoryStore } from "../../directory/directory-store.ts";
import type { EnvironmentStore } from "../../environments/environment-store.ts";
import type { SessionStore } from "../../sessions/session-store.ts";
+import type { SessionStateBus } from "../../runs/session-state-bus.ts";
import type { SessionSyscallsFactory } from "../../sessions/session-syscalls.ts";
import type { DeliveryStore } from "../../delivery/delivery-store.ts";
import type { WorkspaceStore } from "../../workspace/workspace-store.ts";
@@ -125,6 +126,7 @@ export interface OrchestratorDeps {
resolveBaseModelId?: () => string | undefined;
sessionTapeMode?: "shadow" | "serve";
sessions: SessionStore;
+ sessionStateBus?: SessionStateBus;
sessionSyscalls?: SessionSyscallsFactory;
workspace: WorkspaceStore;
files: FileArtifactStore;
diff --git a/src/core/session-title.ts b/src/core/session-title.ts
new file mode 100644
index 000000000..9c3883f4d
--- /dev/null
+++ b/src/core/session-title.ts
@@ -0,0 +1,84 @@
+import type { ErrorLog } from "../admin/error-log.ts";
+import type { Harness } from "../harness/harness.ts";
+import type { SessionStateBus } from "../runs/session-state-bus.ts";
+import type { SessionStore } from "../sessions/session-store.ts";
+import type { ScopeId } from "../types.ts";
+import { errMessage, swallowAs } from "../util/errors.ts";
+import { headSlice } from "../util/text.ts";
+import { stripTurnBoilerplate } from "./orchestrator/turn-helpers.ts";
+import { TitleRejected } from "./turn-error.ts";
+
+function fallbackSessionTitle(text: string): string | undefined {
+ const clean = stripTurnBoilerplate(text).replace(/\s+/g, " ").trim();
+ if (!clean) return undefined;
+ return clean.length > 60 ? `${headSlice(clean, 59).trimEnd()}…` : clean;
+}
+
+export function createSessionTitles(deps: {
+ sessions: SessionStore;
+ harness: Harness;
+ sessionStateBus?: SessionStateBus;
+ errors?: ErrorLog;
+}) {
+ async function generateAndStore(
+ sessionId: string,
+ scopeId: ScopeId,
+ transcript: string,
+ principalId?: string,
+ fallbackText?: string,
+ ): Promise<string | undefined> {
+ if (!transcript.trim()) return undefined;
+ let title: string | undefined;
+ try {
+ title = await deps.harness.models.generateTitle?.(transcript);
+ } catch (e) {
+ deps.errors?.record(
+ {
+ category: "session_title",
+ code: e instanceof TitleRejected ? `rejected_${e.rule}` : "generation_failed",
+ message: errMessage(e),
+ scopeLabel: scopeId,
+ sessionId,
+ },
+ e,
+ );
+ }
+ title ??= fallbackText ? fallbackSessionTitle(fallbackText) : undefined;
+ if (title) {
+ if (principalId) await deps.sessions.updateParticipantView(sessionId, principalId, { title });
+ else await deps.sessions.updateTitle(sessionId, title);
+ }
+ return title;
+ }
+
+ const announce = async (session: { id: string; threadRef: string }) =>
+ deps.sessionStateBus?.emit({
+ threadRef: session.threadRef,
+ sessionId: session.id,
+ participants: await deps.sessions.participantsOf(session.id),
+ state: "metadata",
+ at: Date.now(),
+ });
+
+ function titleFromFirstMessage(
+ session: { id: string; threadRef: string },
+ scopeId: ScopeId,
+ text: string,
+ ): Promise<void> | undefined {
+ const fallback = fallbackSessionTitle(text);
+ if (!fallback) return undefined;
+ const write = deps.sessions.updateTitle(session.id, fallback);
+ void write
+ .then(() => announce(session).catch(swallowAs("session title: sidebar refresh", undefined)))
+ .then(async () => {
+ if (!deps.harness.models.generateTitle) return;
+ if (await generateAndStore(session.id, scopeId, `User:\n${stripTurnBoilerplate(text)}`))
+ await announce(session);
+ })
+ .finally(() => deps.errors?.flush())
+ .catch(swallowAs("session title", undefined));
+ return write;
+ }
+
+ return { generateAndStore, titleFromFirstMessage };
+}
diff --git a/src/wiring.ts b/src/wiring.ts
index a7f697b87..4c40340b5 100644
--- a/src/wiring.ts
+++ b/src/wiring.ts
@@ -1906,6 +1906,7 @@ export function buildApp(
},
});
const orchestratorDeps: OrchestratorDeps = {
+ sessionStateBus,
externalSlackPolicies: config.externalSlackPolicies,
sessionSyscalls,
refreshModels,
diff --git a/test/session-state-events.test.ts b/test/session-state-events.test.ts
index cb85438cb..359f4d564 100644
--- a/test/session-state-events.test.ts
+++ b/test/session-state-events.test.ts
@@ -40,7 +40,7 @@ function parseFrame(data: string): SessionStateEvent | null {
}
function statesFor(events: SessionStateEvent[], threadRef: string): string[] {
- return events.filter((e) => e.threadRef === threadRef).map((e) => e.state);
+ return events.filter((e) => e.threadRef === threadRef && e.state !== "metadata").map((e) => e.state);
}
test("a plain turn emits working then idle", async () => {
@@ -178,7 +178,8 @@ test("GET /v1/session-state/events streams transitions as SSE frames", async ()
?.slice("data: ".length);
if (!data) continue;
const ev = parseFrame(data);
- if (ev && ev.threadRef === "web:U1:sse" && !frames.some((f) => f.state === ev.state)) frames.push(ev);
+ if (ev && ev.threadRef === "web:U1:sse" && ev.state !== "metadata" && !frames.some((f) => f.state === ev.state))
+ frames.push(ev);
}
if (frames.some((f) => f.state === "awaiting_approval")) break;
}
diff --git a/test/session-title.test.ts b/test/session-title.test.ts
index 645709a63..387f2a9d5 100644
--- a/test/session-title.test.ts
+++ b/test/session-title.test.ts
@@ -11,6 +11,7 @@ import { buildApp } from "../src/wiring.ts";
import type { Config } from "../src/config.ts";
import type { TurnRequest } from "../src/types.ts";
import { testConfig } from "./support/test-config.ts";
+import { selectDefaultSandbox } from "./support/default-sandbox.ts";
function freshApp() {
const dataDir = mkdtempSync(join(tmpdir(), "ap-title-"));
@@ -31,6 +32,33 @@ test("names a conversation from its first completed turn (auto-title)", async ()
assert.equal(got?.session.title, "Chat: How do I roll back");
});
+test("the title and its sidebar refresh land before the turn's computer is ready", async () => {
+ const built = freshApp();
+ await selectDefaultSandbox(built, "U1", "personal:U1");
+ const computerReady = Promise.withResolvers<void>();
+ const provision = built.sandbox.provision.bind(built.sandbox);
+ built.sandbox.provision = async (layers, opts) => {
+ await computerReady.promise;
+ return provision(layers, opts);
+ };
+ const refreshed = new Promise<string | undefined>((resolve) => {
+ const off = built.sessionStateBus.subscribe((event) => {
+ if (event.state !== "metadata") return;
+ off();
+ resolve(event.sessionId);
+ });
+ });
+ const turn = built.app.turn({
+ ...dm("Summarize this screenshot of the dashboard", "web:U1:title-before-computer"),
+ attachments: [{ name: "shot.png", mimetype: "image/png", sizeBytes: 3, blobId: "blob-shot" }],
+ });
+
+ const sessionId = await refreshed;
+ assert.match((await built.app.getSession(sessionId!))?.session.title ?? "", /Summarize this screenshot/);
+ computerReady.resolve();
+ assert.equal((await turn).status, "ok");
+});
+
test("concurrent completed turns keep durable titles when title generation is unavailable", async () => {
const { app } = freshApp();
const turns = await Promise.all(