Skip to content

Commit 08f9d7f

Browse files
authored
🧵 feat: Stream a Background Subagent Child Through Its Own Generation Job (#18169)
* 🫀 feat: Let a Job Owner Keep a Silent Run Alive A generation job's idle clock advances only with emitted chunks, so a run that works without output for 20 minutes is reaped while it is still alive. touchJob refreshes the idle clock and the storage lifetimes an append would have extended, fenced on the generation epoch and limited to the replica that owns the runtime. * 🧶 refactor: Share One Fold From Child Frames to Content Parts readSubagentContent folded public child frames into content parts inline. The fold is now a synchronous function a second caller can use, so a frame can be folded and published without yielding in between. * 🏷️ feat: Mark the Generation Job of a Background Subagent Task Job metadata gains subagentTaskId and subagentParentConversationId, set only by the subagent task store. A marked job is a child-thread job, so it stays out of the active chat list, and isBackgroundChildJob tells it apart from an event-bound child, whose job the chat controller owns. * 🧵 feat: Run a Background Child as a Resumable Generation Job createChildGenerationHost opens a generation job keyed by the child thread id and feeds it the child's public step frames. Text deltas that queue behind a slow write merge instead of dropping, the terminal state is claimed before the caller persists and the final event is published only afterwards, and no stream failure can fail the child: the run and its result carry on without a live view. * 🪢 feat: Stream a Background Child Through Its Own Generation Job The subagent task store takes a childGenerations dependency. Once a child's thread and input row are durable it opens a job keyed by the thread id, feeds it each public frame, refreshes its idle clock on every lease renewal, and settles it around its own persistence, so a reader sees the final event only after the result row exists. A cancel, a failure and a job aborted from outside all end both the child and its stream. endpoints.agents.subagentActivity.generationJobs turns it off. A stream that cannot be opened or written never fails the child. * 🔌 feat: Give the Server's Task Store Its Child Stream The host wiring builds the child generation host from the generation job manager and hands it to the subagent task store, so a background child's stream is reachable in the running server. * 🚧 fix: Refuse Chat Abort and Steer on a Background Child's Job The chat abort route saves a user row and a partial response and upserts the conversation, and the steer route queues text only the chat controller drains. Both authorized on the job's owner alone, so either could act on a background child's job and write a chat-shaped history into a view-only thread, or accept a steer nothing would ever apply. Both now answer 409 for a job the subagent task store owns; the child is stopped and steered through its control endpoint. * 🧹 fix: Evict a Finished Job Before a Live One at Capacity The in-memory job store made room by deleting its oldest job whatever its status, so a full store could end a run somebody was still waiting on. It now takes the oldest finished job first. Also covers a job manager that shuts down while a background child runs: the child still persists its cancellation. * 🛰️ test: Read a Background Child's Stream From Another Replica Against real Redis: a second replica resumes with everything the child has streamed, receives only newer deltas live, then the final event; a child that streams past the manager's 5,000-event early buffer before anyone attaches still resumes whole on both replicas; and the owner's touch keeps a silent child's job alive. * 🧽 chore: Sort Imports in the Child Stream Files * 🧪 test: Expect the Child Stream Lever in the Activity Defaults * 📜 feat: Store What a Background Child Streamed as Standard Content (#18173) A child's result row carried its text and a bounded activity projection, not the content parts every agent message stores, so a reader had to rebuild the child's output from the projection. The row now also carries what the child streamed, on completion, failure and cancellation, in the standard shape. endpoints.agents.subagentActivity.generationContentBytes bounds it (4 MiB by default, 0 stores none). Content over the bound is left off, so the row always fits and keeps its text and projection as before. * 🛟 fix: Keep a Stalled or Failing Child Stream From Touching Its Child Four ways the stream could still reach the run it only observes. A frame that could not be copied threw into the child's own progress report. A job store that never answered held the child's start behind job creation and its result behind the terminal claim. And a stream that had stopped being written was never ended, so its job read as a live child for twenty minutes after the child finished. Frames are now copied defensively, opening and settling are bounded, a job that arrives after its child stopped waiting is ended, and a detached stream is still touched and still settled with its full final event. * 🧯 fix: Let a Child Stream Observe Its Run Without Ever Stopping It Review round 1. A failed Redis append retires the job's runtime by aborting its controller, and the child stream forwarded every abort of that controller to the task store as a cancellation. A stream-store outage therefore stopped the child's model and tool work. The stream no longer signals the child at all: deletion, shutdown and the control endpoint already stop a child through the task store, and an aborted, reaped or retired job now only ends the live view. The in-memory store's capacity eviction preferred any terminal job, including one that still owed persistence, a host action, a schedule reconciliation or a provider drain. Those are no longer treated as finished. The chat abort route's refusal for a background child's job moves out of the CJS route into createBackgroundChildAbortGuard, registered ahead of it. * ♻️ fix: Replace a Dead Background Child's Job on Its Thread A background child's job outlives an owner that crashed, or a settlement that could not reach the store, for up to twenty minutes. A continuation of the thread in that window was refused its own stream, because the dead job still read as live. The caller of open holds the thread's lease, so a background child's job still marked live there has lost its owner: it is replaced and its readers are told to refetch. A live job that is not a background child's, such as an event-bound child paused for approval, is still never replaced. * 🧱 fix: Fail the Abort Guard Closed and Budget Content Against the Whole Row Review round 2. The abort guard passed the request on when its job lookup failed, so a retried lookup in the route could run the chat-shaped abort on a child the guard never saw. A failed lookup now ends the request at the error boundary. A child's streamed content was checked against its own limit only. A result row also carries the text and the transcript, so content that passed the limit could push the document past MongoDB's 16 MiB and turn a successful child into a failed one. The content is now the optional field: it is left off whenever the row's large fields together would exceed the budget. Also accounts for the guard's job read in the two abort route specs that sequence it, and gives the limiter spec's api mock the guard. * 🪶 refactor: Settle a Child Stream Once and Fold a Frame It Cannot Copy The task store settles a child's stream on its outcome path and again in its cleanup. The second call made another terminal claim that could only lose; the stream now remembers that it claimed and only persists. A frame that cannot be copied is still folded from the original, so the stored content stays whole when the stream detaches over it. * 🧪 test: Cover the Child Stream's Failure Branches and the Content Fold The change-risk report showed the stream's fail-open branches untested: a terminal claim that lands after its wait, a claim or a final publish that throws, the settle timeout, the backlog limit, and a rejected touch. Each now has a case. The shared content fold gets direct cases for a closed step, a commentary phase and an applied steer.
1 parent 28f26cd commit 08f9d7f

30 files changed

Lines changed: 3019 additions & 103 deletions

‎api/server/routes/agents/__tests__/abort.spec.js‎

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -181,6 +181,41 @@ describe('Agent Abort Endpoint', () => {
181181
);
182182
});
183183

184+
it('should refuse to abort a background child job, which its task store owns', async () => {
185+
const jobStreamId = 'child-thread-123';
186+
187+
mockGenerationJobManager.getJob.mockResolvedValue({
188+
metadata: {
189+
userId: 'test-user-123',
190+
subagentTaskId: 'task-1',
191+
subagentParentConversationId: 'parent-1',
192+
},
193+
});
194+
195+
const response = await request(app)
196+
.post('/api/agents/chat/abort')
197+
.send({ conversationId: jobStreamId });
198+
199+
expect(response.status).toBe(409);
200+
expect(response.body).toMatchObject({ code: 'CHILD_THREAD_READ_ONLY' });
201+
expect(mockGenerationJobManager.abortJob).not.toHaveBeenCalled();
202+
expect(mockSaveMessage).not.toHaveBeenCalled();
203+
expect(mockSaveConvo).not.toHaveBeenCalled();
204+
});
205+
206+
it("should answer 403, not 409, for another user's background child job", async () => {
207+
mockGenerationJobManager.getJob.mockResolvedValue({
208+
metadata: { userId: 'other-user-456', subagentTaskId: 'task-1' },
209+
});
210+
211+
const response = await request(app)
212+
.post('/api/agents/chat/abort')
213+
.send({ conversationId: 'child-thread-123' });
214+
215+
expect(response.status).toBe(403);
216+
expect(mockGenerationJobManager.abortJob).not.toHaveBeenCalled();
217+
});
218+
184219
it('should fail closed when job has no userId metadata', async () => {
185220
const jobStreamId = 'test-stream-123';
186221

‎api/server/routes/agents/__tests__/idempotencyLimiter.spec.js‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -33,6 +33,7 @@ jest.mock('@librechat/data-schemas', () => ({
3333

3434
jest.mock('@librechat/api', () => ({
3535
isEnabled: jest.fn(() => true),
36+
createBackgroundChildAbortGuard: jest.fn(() => (_req, _res, next) => next()),
3637
detectGenerationRetry: async (req, _res, next) => {
3738
req._isConfirmedGenerationRetry = await mockHasGenerationClaim(
3839
req.user?.id,

‎api/server/routes/agents/__tests__/streamTenant.spec.js‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -959,12 +959,18 @@ describe('SSE stream tenant isolation', () => {
959959
});
960960

961961
it('reports an already-settled generation when natural completion wins the abort CAS', async () => {
962+
/** Read by the child-job guard, by the route, and again after the abort lost its CAS. */
962963
mockGenerationJobManager.getJob
963964
.mockResolvedValueOnce({
964965
metadata: { userId: 'user-123', generationProtocolVersion: 2 },
965966
status: 'running',
966967
createdAt: 1000,
967968
})
969+
.mockResolvedValueOnce({
970+
metadata: { userId: 'user-123', generationProtocolVersion: 2 },
971+
status: 'running',
972+
createdAt: 1000,
973+
})
968974
.mockResolvedValueOnce({
969975
metadata: { userId: 'user-123', generationProtocolVersion: 2 },
970976
status: 'complete',
@@ -996,12 +1002,18 @@ describe('SSE stream tenant isolation', () => {
9961002
});
9971003

9981004
it('keeps the legacy abort ACK shape when natural completion wins for protocol v1', async () => {
1005+
/** Read by the child-job guard, by the route, and again after the abort lost its CAS. */
9991006
mockGenerationJobManager.getJob
10001007
.mockResolvedValueOnce({
10011008
metadata: { userId: 'user-123', generationProtocolVersion: 1 },
10021009
status: 'running',
10031010
createdAt: 1000,
10041011
})
1012+
.mockResolvedValueOnce({
1013+
metadata: { userId: 'user-123', generationProtocolVersion: 1 },
1014+
status: 'running',
1015+
createdAt: 1000,
1016+
})
10051017
.mockResolvedValueOnce({
10061018
metadata: { userId: 'user-123', generationProtocolVersion: 1 },
10071019
status: 'complete',

‎api/server/routes/agents/index.js‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ const {
33
reportLocatorTraversalFailure,
44
isEnabled,
55
GenerationJobManager,
6+
createBackgroundChildAbortGuard,
67
TERMINAL_PUBLICATION_RECONNECT_ERROR,
78
hasPersistableAbortContent,
89
announceStoppedReply,
@@ -622,6 +623,12 @@ router.get('/chat/status/:conversationId', async (req, res) => {
622623
* @access Private
623624
* @description Mounted before chatRouter to bypass buildEndpointOption middleware
624625
*/
626+
router.post(
627+
'/chat/abort',
628+
createBackgroundChildAbortGuard({
629+
getJob: (streamId) => GenerationJobManager.getJob(streamId),
630+
}),
631+
);
625632
router.post('/chat/abort', chatConfigMiddleware, async (req, res, next) => {
626633
logger.debug(`[AgentStream] ========== ABORT ENDPOINT HIT ==========`);
627634
logger.debug(`[AgentStream] Method: ${req.method}, Path: ${req.path}`);

‎api/server/services/Endpoints/agents/subagentThreadStore.js‎

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -5,6 +5,7 @@ const {
55
duplicateIoRedisClient,
66
createIoRedisSubscriber,
77
createSubagentThreadTaskStore,
8+
createChildGenerationHost,
89
createSubagentCompletionWakeupHandler,
910
GenerationJobManager,
1011
RedisSubagentTaskControlTransport,
@@ -80,6 +81,7 @@ const subagentThreadTaskStore = createSubagentThreadTaskStore(
8081
renewOwnerAdmission: db.renewSubagentAdmission,
8182
releaseOwnerAdmission: db.releaseSubagentAdmission,
8283
cancelUnroutedTask: cancelUnroutedGeneration,
84+
childGenerations: createChildGenerationHost(GenerationJobManager),
8385
onTaskPrepared: completionWakeupHandler,
8486
onTaskSettled: (userId, conversationId, taskIds) =>
8587
expediteCompletionWakeups({ user: userId, conversationId, taskIds }),

‎api/server/services/Endpoints/agents/subagentThreadStore.spec.js‎

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,8 @@ const mockTaskStore = {
77
destroyActivityStream: jest.fn(),
88
};
99
const mockCompletionWakeupHandler = jest.fn().mockResolvedValue(undefined);
10+
const mockChildGenerations = { open: jest.fn() };
11+
const mockGenerationJobManager = { getJob: jest.fn(), abortJob: jest.fn() };
1012

1113
jest.mock('@librechat/api', () => ({
1214
cacheConfig: { USE_REDIS: true, REDIS_KEY_PREFIX: 'test:' },
@@ -15,6 +17,8 @@ jest.mock('@librechat/api', () => ({
1517
duplicateIoRedisClient: jest.fn(),
1618
createIoRedisSubscriber: jest.fn(),
1719
createSubagentThreadTaskStore: jest.fn(() => mockTaskStore),
20+
createChildGenerationHost: jest.fn(() => mockChildGenerations),
21+
GenerationJobManager: mockGenerationJobManager,
1822
createSubagentCompletionWakeupHandler: jest.fn(() => mockCompletionWakeupHandler),
1923
RedisSubagentTaskControlTransport: jest.fn(),
2024
RedisEventTransport: jest.fn(),
@@ -54,12 +58,14 @@ const {
5458
registerShutdownTask,
5559
duplicateIoRedisClient,
5660
createIoRedisSubscriber,
61+
createChildGenerationHost,
5762
createSubagentThreadTaskStore,
5863
} = require('@librechat/api');
5964
const subagentThreadTaskStore = require('./subagentThreadStore');
6065
const { configureSubagentTaskRouting } = subagentThreadTaskStore;
6166
const taskStoreOptions = createSubagentThreadTaskStore.mock.calls[0][1];
6267
const taskStoreMethods = createSubagentThreadTaskStore.mock.calls[0][0];
68+
const childGenerationHostArgs = createChildGenerationHost.mock.calls[0];
6369
const db = require('~/models');
6470
const activityPrepareRegistration = registerShutdownTask.mock.calls.find(
6571
([name]) => name === 'subagent activity streams prepare',
@@ -76,6 +82,11 @@ describe('subagent thread Redis lifecycle', () => {
7682
expect(taskStoreMethods.getSubagentTaskControlReplay).toBe(db.getSubagentTaskControlReplay);
7783
});
7884

85+
it('gives the host store a child stream backed by the generation job manager', () => {
86+
expect(childGenerationHostArgs).toEqual([mockGenerationJobManager]);
87+
expect(taskStoreOptions.childGenerations).toBe(mockChildGenerations);
88+
});
89+
7990
it('pre-registers completion wakeups for every prepared task', async () => {
8091
await taskStoreOptions.onTaskPrepared({ taskId: 'task-1' });
8192

‎packages/api/src/agents/guard.spec.ts‎

Lines changed: 100 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@ import request from 'supertest';
33
import type { AllMethods, IConversation } from '@librechat/data-schemas';
44
import {
55
CHILD_THREAD_READ_ONLY_ERROR,
6+
createBackgroundChildAbortGuard,
67
createSubagentThreadTurnGuard,
78
isSubagentThreadWriteBlocked,
89
} from './guard';
@@ -354,3 +355,102 @@ describe('subagent child-thread write policy', () => {
354355
expect(getConvo).toHaveBeenCalledWith('owner', 'child-conversation');
355356
});
356357
});
358+
359+
describe('background child abort guard', () => {
360+
const childJob = { metadata: { userId: 'owner', subagentTaskId: 'task-1' } };
361+
362+
function abortApp(
363+
getJob: (streamId: string) => Promise<unknown>,
364+
user: { id?: string; tenantId?: string } = { id: 'owner' },
365+
) {
366+
const app = express();
367+
app.use(express.json());
368+
app.use((req, _res, next) => {
369+
(req as express.Request & { user?: typeof user }).user = user;
370+
next();
371+
});
372+
app.post(
373+
'/abort',
374+
createBackgroundChildAbortGuard({
375+
getJob: getJob as Parameters<typeof createBackgroundChildAbortGuard>[0]['getJob'],
376+
}),
377+
(_req, res) => {
378+
res.status(200).json({ reached: 'route' });
379+
},
380+
);
381+
return app;
382+
}
383+
384+
it("answers 409 for the owner's background child job without reaching the route", async () => {
385+
const getJob = jest.fn(async () => childJob);
386+
387+
const response = await request(abortApp(getJob)).post('/abort').send({ streamId: 'thread-1' });
388+
389+
expect(response.status).toBe(409);
390+
expect(response.body).toEqual({
391+
code: 'CHILD_THREAD_READ_ONLY',
392+
error: CHILD_THREAD_READ_ONLY_ERROR,
393+
});
394+
expect(getJob).toHaveBeenCalledWith('thread-1');
395+
});
396+
397+
it.each([
398+
['conversationId', { conversationId: 'thread-1' }],
399+
['abortKey', { abortKey: 'thread-1:suffix' }],
400+
['the first concrete id after a placeholder', { streamId: 'new', conversationId: 'thread-1' }],
401+
])('reads the target from %s', async (_name, body) => {
402+
const getJob = jest.fn(async () => childJob);
403+
404+
const response = await request(abortApp(getJob)).post('/abort').send(body);
405+
406+
expect(response.status).toBe(409);
407+
expect(getJob).toHaveBeenCalledWith('thread-1');
408+
});
409+
410+
it.each([
411+
['an ordinary chat job', { metadata: { userId: 'owner' } }],
412+
["another user's child job", { metadata: { userId: 'someone-else', subagentTaskId: 't' } }],
413+
[
414+
"another tenant's child job",
415+
{ metadata: { userId: 'owner', tenantId: 'tenant-b', subagentTaskId: 't' } },
416+
],
417+
['a job with no owner', { metadata: { subagentTaskId: 't' } }],
418+
['no job', undefined],
419+
])('falls through to the route for %s', async (_name, job) => {
420+
const response = await request(abortApp(async () => job, { id: 'owner', tenantId: 'tenant-a' }))
421+
.post('/abort')
422+
.send({ streamId: 'thread-1' });
423+
424+
expect(response.body).toEqual({ reached: 'route' });
425+
});
426+
427+
it('falls through without reading a job for a placeholder, a missing id or no user', async () => {
428+
const getJob = jest.fn(async () => childJob);
429+
430+
for (const body of [{ streamId: 'new' }, {}, { streamId: 42 }, { streamId: 'x'.repeat(513) }]) {
431+
const response = await request(abortApp(getJob)).post('/abort').send(body);
432+
expect(response.body).toEqual({ reached: 'route' });
433+
}
434+
const anonymous = await request(abortApp(getJob, {})).post('/abort').send({ streamId: 't' });
435+
expect(anonymous.body).toEqual({ reached: 'route' });
436+
expect(getJob).not.toHaveBeenCalled();
437+
});
438+
439+
it('fails closed, without reaching the route, when the job lookup fails', async () => {
440+
const consoleError = jest.spyOn(console, 'error').mockImplementation();
441+
try {
442+
const response = await request(
443+
abortApp(async () => {
444+
throw new Error('store down');
445+
}),
446+
)
447+
.post('/abort')
448+
.send({ streamId: 'thread-1' });
449+
450+
expect(response.status).toBe(500);
451+
expect(response.body).not.toEqual({ reached: 'route' });
452+
} finally {
453+
consoleError.mockRestore();
454+
}
455+
});
456+
});

‎packages/api/src/agents/guard.ts‎

Lines changed: 87 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,93 @@ import { isAgentEventRetentionActive } from './eventRetention';
99
export const CHILD_THREAD_READ_ONLY_ERROR =
1010
'This subagent thread is view-only. Continue it from its parent agent or create a separate chat.';
1111

12+
export const CHILD_THREAD_READ_ONLY_CODE = 'CHILD_THREAD_READ_ONLY';
13+
14+
export type BackgroundChildJobRefusal = {
15+
status: 409;
16+
body: { code: typeof CHILD_THREAD_READ_ONLY_CODE; error: string };
17+
};
18+
19+
/**
20+
* The answer for a chat route asked to end or steer a background child's job. The subagent
21+
* task store owns that run: it stops and steers the child through its own control endpoint
22+
* and writes the child's rows itself, so a chat route acting on the job would write a second,
23+
* chat-shaped history into a view-only thread. Null for every other job.
24+
*/
25+
type AbortGuardJob = {
26+
metadata?: { userId?: string; tenantId?: string; subagentTaskId?: string };
27+
};
28+
29+
const MAX_ABORT_TARGET_LENGTH = 512;
30+
31+
/** The concrete stream id an abort request names, in the route's own order. The `new`
32+
* placeholder names none: its fallback reads the active chat list, which holds no child. */
33+
function abortTargetId(body: unknown): string | null {
34+
if (body == null || typeof body !== 'object') return null;
35+
const { streamId, conversationId, abortKey } = body as Record<string, unknown>;
36+
const prefix = typeof abortKey === 'string' ? abortKey.split(':')[0] : undefined;
37+
for (const value of [streamId, conversationId, prefix]) {
38+
if (
39+
typeof value === 'string' &&
40+
value !== '' &&
41+
value !== 'new' &&
42+
value.length <= MAX_ABORT_TARGET_LENGTH
43+
) {
44+
return value;
45+
}
46+
}
47+
return null;
48+
}
49+
50+
/**
51+
* Runs ahead of the chat abort route and answers for a background child's job, so the
52+
* route's chat-shaped abort never reaches it. Every other request falls through untouched,
53+
* including one for a job the caller does not own, which the route refuses itself. A job
54+
* lookup that fails ends the request at the error boundary.
55+
*/
56+
export function createBackgroundChildAbortGuard(deps: {
57+
getJob: (streamId: string) => Promise<AbortGuardJob | null | undefined>;
58+
}): RequestHandler {
59+
return async (req, res, next) => {
60+
const streamId = abortTargetId(req.body);
61+
const user = (req as Request & { user?: { id?: string; tenantId?: string } }).user;
62+
if (streamId == null || user?.id == null) {
63+
next();
64+
return;
65+
}
66+
let job: AbortGuardJob | null | undefined;
67+
try {
68+
job = await deps.getJob(streamId);
69+
} catch (error) {
70+
/** Fail closed: the route reads the job again, and a read that then succeeds would
71+
* run its chat-shaped abort on a child this guard never got to see. */
72+
next(error);
73+
return;
74+
}
75+
const metadata = job?.metadata;
76+
const owned =
77+
metadata?.userId === user.id &&
78+
(metadata.tenantId == null || metadata.tenantId === user.tenantId);
79+
const refusal = owned ? backgroundChildJobRefusal(job) : null;
80+
if (refusal == null) {
81+
next();
82+
return;
83+
}
84+
res.status(refusal.status).json(refusal.body);
85+
};
86+
}
87+
88+
export function backgroundChildJobRefusal(
89+
job: { metadata?: { subagentTaskId?: string } } | null | undefined,
90+
): BackgroundChildJobRefusal | null {
91+
const taskId = job?.metadata?.subagentTaskId;
92+
if (taskId == null || taskId === '') return null;
93+
return {
94+
status: 409,
95+
body: { code: CHILD_THREAD_READ_ONLY_CODE, error: CHILD_THREAD_READ_ONLY_ERROR },
96+
};
97+
}
98+
1299
interface SubagentTurnBody {
13100
conversationId?: unknown;
14101
arg?: { conversationId?: unknown };

‎packages/api/src/agents/index.ts‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -65,6 +65,7 @@ export * from './subagentThreads';
6565
export * from './subagentActivity';
6666
export * from './aggregation';
6767
export * from './subagentContent';
68+
export * from './subagentGeneration';
6869
export * from './subagentIdentity';
6970
export * from './subagentCompletionWakeup';
7071
export * from './subagentTaskRouting';

0 commit comments

Comments
 (0)