mirror of
https://github.com/danny-avila/LibreChat.git
synced 2026-11-22 07:52:34 +00:00
* feat: Add graph subagent integration * style: Sort response usage test imports * fix: Preserve lazy graph runtime context * fix: Use isolated graph input helper * test: Align graph integration fixtures * fix: Preserve lazy graph runtime capabilities * fix: Bound lazy graph metadata preload * fix: Harden lazy graph resolution lifecycle * fix: Coalesce lazy graph member resolution * fix: Snapshot initialized graph members only * fix: Preserve lazy agent runtime context * fix: Preserve batched lazy context preparation * fix: Preserve graph member capability bounds * fix: reconcile graph subagents with execution profiles * style: align graph subagent types with formatter
600 lines
23 KiB
TypeScript
600 lines
23 KiB
TypeScript
import { Constants } from '@librechat/agents';
|
|
import type { CodeEnvFile, CodeSessionContext, ToolSessionMap } from '@librechat/agents';
|
|
import {
|
|
buildAgentInitialToolSessions,
|
|
buildInitialToolSessions,
|
|
collectCodeExecutionProfileRoutes,
|
|
seedCodeFilesIntoSessions,
|
|
type CodeFilesAgent,
|
|
} from './codeFilesSession';
|
|
|
|
const file = (id: string, storage_session_id: string, name: string): CodeEnvFile => ({
|
|
id,
|
|
/* `resource_id` is informational for `kind: 'user'` (codeapi derives
|
|
* the sessionKey from the auth-context user, not this field) but
|
|
* still required by the type for shape uniformity. The id stand-in
|
|
* is fine here because no test asserts on its value. */
|
|
resource_id: id,
|
|
storage_session_id,
|
|
name,
|
|
/* `kind` drives codeapi's sessionKey shape; defaults to `'user'` for
|
|
* primed code-execution attachments at the test boundary (most are
|
|
* chat uploads). Tests that need shared kinds set it explicitly. */
|
|
kind: 'user',
|
|
});
|
|
|
|
describe('seedCodeFilesIntoSessions', () => {
|
|
it('returns existing map untouched when files is undefined', () => {
|
|
const existing: ToolSessionMap = new Map();
|
|
expect(seedCodeFilesIntoSessions(undefined, existing)).toBe(existing);
|
|
});
|
|
|
|
it('returns existing map untouched when files is empty', () => {
|
|
const existing: ToolSessionMap = new Map();
|
|
expect(seedCodeFilesIntoSessions([], existing)).toBe(existing);
|
|
});
|
|
|
|
it('returns undefined when no files and no existing map', () => {
|
|
expect(seedCodeFilesIntoSessions(undefined, undefined)).toBeUndefined();
|
|
});
|
|
|
|
it('creates a new sessions map seeded with EXECUTE_CODE entry on first call', () => {
|
|
const files = [file('f1', 'sess-1', 'data.csv')];
|
|
const result = seedCodeFilesIntoSessions(files, undefined);
|
|
|
|
expect(result).toBeDefined();
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.session_id).toBe('sess-1');
|
|
expect(entry.files).toEqual(files);
|
|
expect(typeof entry.lastUpdated).toBe('number');
|
|
});
|
|
|
|
it('mutates the passed-in map (in-place seeding so caller can pass to createRun)', () => {
|
|
const existing: ToolSessionMap = new Map();
|
|
const result = seedCodeFilesIntoSessions([file('f1', 'sess-1', 'a.csv')], existing);
|
|
expect(result).toBe(existing);
|
|
expect(existing.has(Constants.EXECUTE_CODE)).toBe(true);
|
|
});
|
|
|
|
it('appends incoming files to a prior EXECUTE_CODE entry without dropping skill files', () => {
|
|
const skillFile = file('skill-1', 'skill-sess', 'skill/util.py');
|
|
const codeFile = file('user-1', 'user-sess', 'data.csv');
|
|
|
|
const existing: ToolSessionMap = new Map();
|
|
existing.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'skill-sess',
|
|
files: [skillFile],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = seedCodeFilesIntoSessions([codeFile], existing);
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toEqual([skillFile, codeFile]);
|
|
expect(entry.session_id).toBe('skill-sess');
|
|
});
|
|
|
|
it('preserves prior representative session_id when merging', () => {
|
|
const existing: ToolSessionMap = new Map();
|
|
existing.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'skill-sess',
|
|
files: [file('skill-1', 'skill-sess', 'a.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = seedCodeFilesIntoSessions([file('user-1', 'different-sess', 'b.csv')], existing);
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.session_id).toBe('skill-sess');
|
|
});
|
|
|
|
it('skips seeding when incoming files have no storage_session_id (defensive)', () => {
|
|
const fileWithoutSession = {
|
|
id: 'x',
|
|
storage_session_id: '',
|
|
name: 'orphan.csv',
|
|
kind: 'user',
|
|
} as CodeEnvFile;
|
|
const result = seedCodeFilesIntoSessions([fileWithoutSession], undefined);
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
it('dedupes incoming files that share storage_session_id + id with existing entries', () => {
|
|
/**
|
|
* Regression for Codex review #2: shared conversation files commonly
|
|
* appear in multiple agents' `primedCodeFiles`. Without dedupe,
|
|
* `_injected_files` would grow proportionally to agent count and
|
|
* inflate every `/exec` POST.
|
|
*/
|
|
const shared = file('f1', 'sess-S', 'shared.csv');
|
|
const result = seedCodeFilesIntoSessions([shared, shared, shared], undefined);
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(1);
|
|
expect(entry.files![0].id).toBe('f1');
|
|
});
|
|
|
|
it('dedupes incoming files against pre-existing entries on merge', () => {
|
|
const existing: ToolSessionMap = new Map();
|
|
existing.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'skill-sess',
|
|
files: [file('skill-1', 'skill-sess', 'a.py'), file('shared-1', 'sess-S', 'shared.csv')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = seedCodeFilesIntoSessions(
|
|
[
|
|
file('shared-1', 'sess-S', 'shared.csv'), // duplicate of prior entry
|
|
file('new-1', 'sess-N', 'new.csv'),
|
|
],
|
|
existing,
|
|
);
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
/* prior 2 + 1 new (the duplicate is dropped). */
|
|
expect(entry.files).toHaveLength(3);
|
|
expect(entry.files!.map((f) => f.id).sort()).toEqual(['new-1', 'shared-1', 'skill-1']);
|
|
});
|
|
|
|
it('treats same name + same session as a duplicate; same name + different sessions as distinct', () => {
|
|
/**
|
|
* The dedupe key is `(session_id, id)` — not `name` alone. Two
|
|
* primed uploads can legitimately share a filename when they live
|
|
* in different sandbox sessions (e.g. each agent re-uploaded the
|
|
* same source file). Both should land in the seed.
|
|
*/
|
|
const a = file('id-A', 'sess-A', 'data.csv');
|
|
const b = file('id-B', 'sess-B', 'data.csv');
|
|
const result = seedCodeFilesIntoSessions([a, a, b], undefined);
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(2);
|
|
expect(entry.files!.map((f) => f.storage_session_id).sort()).toEqual(['sess-A', 'sess-B']);
|
|
});
|
|
|
|
it('seeds only the requested code-session partition', () => {
|
|
const statefulKey = 'execute_code:stateful:v1:user';
|
|
const existing: ToolSessionMap = new Map();
|
|
existing.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'stateless-session',
|
|
files: [file('s1', 'stateless-session', 'stateless.txt')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = seedCodeFilesIntoSessions(
|
|
[file('w1', 'stateful-session', 'stateful.txt')],
|
|
existing,
|
|
statefulKey,
|
|
);
|
|
|
|
expect(result!.get(Constants.EXECUTE_CODE)?.files?.map((f) => f.id)).toEqual(['s1']);
|
|
expect(result!.get(statefulKey)?.files?.map((f) => f.id)).toEqual(['w1']);
|
|
});
|
|
});
|
|
|
|
describe('buildAgentInitialToolSessions', () => {
|
|
it('clones only the agent partition and merges files resolved after the run seed', () => {
|
|
const statefulKey = 'execute_code:stateful:v2:user:user-1';
|
|
const statelessFile = file('stateless', 'stateless-session', 'stateless.txt');
|
|
const skillFile = file('skill', 'stateful-skill-session', 'skills/tool.py');
|
|
const lazyAttachment = file('attachment', 'stateful-user-session', 'input.csv');
|
|
const runSessions: ToolSessionMap = new Map([
|
|
[
|
|
Constants.EXECUTE_CODE,
|
|
{
|
|
session_id: statelessFile.storage_session_id,
|
|
files: [statelessFile],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext,
|
|
],
|
|
[
|
|
statefulKey,
|
|
{
|
|
session_id: skillFile.storage_session_id,
|
|
files: [skillFile],
|
|
lastUpdated: 2,
|
|
} satisfies CodeSessionContext,
|
|
],
|
|
]);
|
|
|
|
const result = buildAgentInitialToolSessions(
|
|
{ codeSessionKey: statefulKey, primedCodeFiles: [lazyAttachment] },
|
|
runSessions,
|
|
);
|
|
|
|
expect(result?.has(Constants.EXECUTE_CODE)).toBe(false);
|
|
expect(result?.get(statefulKey)?.files?.map((entry) => entry.id)).toEqual([
|
|
'skill',
|
|
'attachment',
|
|
]);
|
|
expect(result).not.toBe(runSessions);
|
|
expect(runSessions.get(statefulKey)?.files?.map((entry) => entry.id)).toEqual(['skill']);
|
|
});
|
|
});
|
|
|
|
describe('buildInitialToolSessions', () => {
|
|
const agent = (
|
|
name: string,
|
|
primedCodeFiles?: CodeEnvFile[],
|
|
subagents?: CodeFilesAgent[],
|
|
codeSessionKey?: string,
|
|
): CodeFilesAgent & { __label: string } => ({
|
|
__label: name,
|
|
codeSessionKey,
|
|
primedCodeFiles,
|
|
subagentAgentConfigs: subagents,
|
|
});
|
|
|
|
it('returns the skill sessions untouched when no agent contributes files', () => {
|
|
const skillSessions: ToolSessionMap = new Map();
|
|
skillSessions.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'skill-sess',
|
|
files: [file('s1', 'skill-sess', 'a.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = buildInitialToolSessions({
|
|
skillSessions,
|
|
agents: [agent('primary'), agent('handoff')],
|
|
});
|
|
|
|
expect(result).toBe(skillSessions);
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(1);
|
|
});
|
|
|
|
it('returns undefined when no skills and no agents have primed files', () => {
|
|
const result = buildInitialToolSessions({
|
|
skillSessions: undefined,
|
|
agents: [agent('primary')],
|
|
});
|
|
expect(result).toBeUndefined();
|
|
});
|
|
|
|
it('merges primary + handoff agents into one EXECUTE_CODE entry', () => {
|
|
const primary = agent('primary', [file('p1', 'sess-P', 'data.csv')]);
|
|
const handoff = agent('handoff', [file('h1', 'sess-H', 'report.md')]);
|
|
|
|
const result = buildInitialToolSessions({
|
|
agents: [primary, handoff],
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(2);
|
|
expect(entry.files!.map((f) => f.name).sort()).toEqual(['data.csv', 'report.md']);
|
|
});
|
|
|
|
it('walks recursively into subagentAgentConfigs (P2 fix)', () => {
|
|
/**
|
|
* Pure subagents are pruned out of `agentConfigs` after init but
|
|
* retained on the parent's `subagentAgentConfigs`. The recursive
|
|
* walk picks them up so their primed code files seed the same
|
|
* shared `Graph.sessions[EXECUTE_CODE]` entry.
|
|
*/
|
|
const grandchild = agent('grandchild', [file('g1', 'sess-G', 'nested.txt')]);
|
|
const child = agent('child', [file('c1', 'sess-C', 'mid.txt')], [grandchild]);
|
|
const primary = agent('primary', [file('p1', 'sess-P', 'top.txt')], [child]);
|
|
|
|
const result = buildInitialToolSessions({
|
|
agents: [primary],
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
const names = entry.files!.map((f) => f.name).sort();
|
|
expect(names).toEqual(['mid.txt', 'nested.txt', 'top.txt']);
|
|
});
|
|
|
|
it('includes graph-subagent members pruned from the top-level agent map', () => {
|
|
const member = agent('graph-member', [file('g1', 'sess-G', 'team.txt')]);
|
|
const primary = agent('primary');
|
|
primary.subagentGraphConfigs = [{ memberConfigs: [member] }];
|
|
|
|
const result = buildInitialToolSessions({ agents: [primary] });
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files!.map((item) => item.name)).toEqual(['team.txt']);
|
|
});
|
|
|
|
it('preserves the skill side representative session_id when merging', () => {
|
|
const skillSessions: ToolSessionMap = new Map();
|
|
skillSessions.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'skill-sess',
|
|
files: [file('s1', 'skill-sess', 'a.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = buildInitialToolSessions({
|
|
skillSessions,
|
|
agents: [agent('primary', [file('p1', 'agent-sess', 'b.csv')])],
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.session_id).toBe('skill-sess');
|
|
expect(entry.files).toHaveLength(2);
|
|
});
|
|
|
|
it('does not infinite-loop on a cycle in the subagent graph', () => {
|
|
/**
|
|
* Defensive: a misconfigured subagent graph can have A → B → A.
|
|
* The visited Set keyed on object identity must terminate the walk.
|
|
*/
|
|
const a = agent('A', [file('a1', 'sess-A', 'a.txt')]);
|
|
const b = agent('B', [file('b1', 'sess-B', 'b.txt')]);
|
|
a.subagentAgentConfigs = [b];
|
|
b.subagentAgentConfigs = [a];
|
|
|
|
const result = buildInitialToolSessions({ agents: [a] });
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files!.map((f) => f.name).sort()).toEqual(['a.txt', 'b.txt']);
|
|
});
|
|
|
|
it('skips undefined / null entries in the agents iterable (defensive)', () => {
|
|
const result = buildInitialToolSessions({
|
|
agents: [undefined, agent('primary', [file('p1', 'sess-P', 'x.txt')]), null] as Array<
|
|
CodeFilesAgent | undefined | null
|
|
>,
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(1);
|
|
expect(entry.files![0].name).toBe('x.txt');
|
|
});
|
|
|
|
it('walks primary-first so the primary supplies the representative session_id (no skill seed)', () => {
|
|
/**
|
|
* Regression: a LIFO stack would visit the last top-level agent
|
|
* first, flipping which agent's first file becomes the
|
|
* representative `session_id` written to the EXECUTE_CODE entry.
|
|
* The walk is FIFO so the primary always lands first.
|
|
*/
|
|
const primary = agent('primary', [file('p1', 'sess-PRIMARY', 'top.txt')]);
|
|
const handoffA = agent('handoff-A', [file('a1', 'sess-A', 'a.txt')]);
|
|
const handoffB = agent('handoff-B', [file('b1', 'sess-B', 'b.txt')]);
|
|
|
|
const result = buildInitialToolSessions({
|
|
agents: [primary, handoffA, handoffB],
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.session_id).toBe('sess-PRIMARY');
|
|
/* All three agents still contributed their files into the merged set. */
|
|
expect(entry.files!.map((f) => f.name).sort()).toEqual(['a.txt', 'b.txt', 'top.txt']);
|
|
/* And the per-file storage_session_ids are preserved (ToolNode injects per-file). */
|
|
const byName = new Map(entry.files!.map((f) => [f.name, f.storage_session_id]));
|
|
expect(byName.get('top.txt')).toBe('sess-PRIMARY');
|
|
expect(byName.get('a.txt')).toBe('sess-A');
|
|
expect(byName.get('b.txt')).toBe('sess-B');
|
|
});
|
|
|
|
it('dedupes shared conversation files across multiple run agents (Codex review #2)', () => {
|
|
/**
|
|
* The realistic case: a conversation with a primary + handoff +
|
|
* subagent all sharing the SAME `tool_resources.execute_code`
|
|
* file_ids. Without dedupe, the same file ref would land in
|
|
* `_injected_files` 3 times and bloat the `/exec` POST. With
|
|
* dedupe, exactly one ref reaches the sandbox.
|
|
*/
|
|
const sharedFile = file('shared-id', 'sess-shared', 'data.csv');
|
|
const result = buildInitialToolSessions({
|
|
agents: [
|
|
agent('primary', [sharedFile, file('p1', 'sess-P', 'private.csv')]),
|
|
agent('handoff', [sharedFile]),
|
|
agent('subagent', [sharedFile, file('s1', 'sess-S', 'sub.csv')]),
|
|
],
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(3);
|
|
expect(entry.files!.map((f) => f.id).sort()).toEqual(['p1', 's1', 'shared-id']);
|
|
});
|
|
|
|
it('deduplicates a single agent referenced as both primary and a subagent', () => {
|
|
/**
|
|
* `agentConfigs` may include an agent that is also a subagent of
|
|
* another. Visiting it twice would double-merge its files. The
|
|
* visited Set prevents that.
|
|
*/
|
|
const shared = agent('shared', [file('s1', 'sess-S', 'shared.csv')]);
|
|
const primary = agent('primary', [file('p1', 'sess-P', 'top.csv')], [shared]);
|
|
|
|
const result = buildInitialToolSessions({
|
|
agents: [primary, shared],
|
|
});
|
|
|
|
const entry = result!.get(Constants.EXECUTE_CODE) as CodeSessionContext;
|
|
expect(entry.files).toHaveLength(2);
|
|
expect(entry.files!.map((f) => f.name).sort()).toEqual(['shared.csv', 'top.csv']);
|
|
});
|
|
|
|
it('keeps stateless and stateful agent files in separate partitions', () => {
|
|
const statefulKey = 'execute_code:stateful:v1:user';
|
|
const skillSessions: ToolSessionMap = new Map();
|
|
skillSessions.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'skill-sess',
|
|
files: [file('skill-1', 'skill-sess', 'skill.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
skillSessions.set(statefulKey, {
|
|
session_id: 'stateful-skill-sess',
|
|
files: [file('stateful-skill-1', 'stateful-skill-sess', 'skill.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = buildInitialToolSessions({
|
|
skillSessions,
|
|
agents: [
|
|
agent('stateless', [file('s1', 'stateless-sess', 'stateless.txt')]),
|
|
agent('stateful', [file('w1', 'stateful-sess', 'stateful.txt')], undefined, statefulKey),
|
|
],
|
|
});
|
|
|
|
expect(result!.get(Constants.EXECUTE_CODE)?.files?.map((f) => f.id)).toEqual(['skill-1', 's1']);
|
|
expect(result!.get(statefulKey)?.files?.map((f) => f.id)).toEqual(['stateful-skill-1', 'w1']);
|
|
});
|
|
|
|
it('shares user-scoped stateful files but isolates agent-user scopes', () => {
|
|
const userKey = 'execute_code:stateful:v1:user';
|
|
const firstAgentKey = 'execute_code:stateful:v1:agent-user:agent-a';
|
|
const secondAgentKey = 'execute_code:stateful:v1:agent-user:agent-b';
|
|
|
|
const result = buildInitialToolSessions({
|
|
agents: [
|
|
agent('user-a', [file('u1', 'user-a-sess', 'a.txt')], undefined, userKey),
|
|
agent('user-b', [file('u2', 'user-b-sess', 'b.txt')], undefined, userKey),
|
|
agent('agent-a', [file('a1', 'agent-a-sess', 'private-a.txt')], undefined, firstAgentKey),
|
|
agent('agent-b', [file('b1', 'agent-b-sess', 'private-b.txt')], undefined, secondAgentKey),
|
|
],
|
|
});
|
|
|
|
expect(result!.get(userKey)?.files?.map((f) => f.id)).toEqual(['u1', 'u2']);
|
|
expect(result!.get(firstAgentKey)?.files?.map((f) => f.id)).toEqual(['a1']);
|
|
expect(result!.get(secondAgentKey)?.files?.map((f) => f.id)).toEqual(['b1']);
|
|
expect(result!.has(Constants.EXECUTE_CODE)).toBe(false);
|
|
});
|
|
|
|
it('preserves a profile-local stateful skill seed without agent files', () => {
|
|
const statefulKey = 'execute_code:stateful:v1:user';
|
|
const skillSessions: ToolSessionMap = new Map();
|
|
skillSessions.set(statefulKey, {
|
|
session_id: 'skill-sess',
|
|
files: [file('skill-1', 'skill-sess', 'skill.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = buildInitialToolSessions({
|
|
skillSessions,
|
|
agents: [agent('stateful', undefined, undefined, statefulKey)],
|
|
});
|
|
|
|
expect(result!.get(statefulKey)?.files?.map((f) => f.id)).toEqual(['skill-1']);
|
|
});
|
|
|
|
it('never copies a default-profile skill pointer into a stateful partition', () => {
|
|
const statefulKey = 'execute_code:stateful:v1:user';
|
|
const skillSessions: ToolSessionMap = new Map();
|
|
skillSessions.set(Constants.EXECUTE_CODE, {
|
|
session_id: 'default-skill-sess',
|
|
files: [file('skill-1', 'default-skill-sess', 'skill.py')],
|
|
lastUpdated: 1,
|
|
} satisfies CodeSessionContext);
|
|
|
|
const result = buildInitialToolSessions({
|
|
skillSessions,
|
|
agents: [agent('stateful', undefined, undefined, statefulKey)],
|
|
});
|
|
|
|
expect(result!.has(statefulKey)).toBe(false);
|
|
});
|
|
});
|
|
|
|
describe('collectCodeExecutionProfileRoutes', () => {
|
|
it('groups reachable code agents by deployment and retains each trusted partition', () => {
|
|
const statelessContext = {
|
|
baseUrl: 'https://code.example.com/v1',
|
|
codeSessionKey: Constants.EXECUTE_CODE,
|
|
executionProfile: 'default' as const,
|
|
statefulSessions: false,
|
|
};
|
|
const statefulContext = (key: string) => ({
|
|
baseUrl: 'https://stateful.example.com/v1',
|
|
codeSessionKey: key,
|
|
executionProfile: 'stateful' as const,
|
|
runtimeSessionHint: key.slice('execute_code:stateful:'.length),
|
|
statefulSessions: true,
|
|
});
|
|
const childKey = 'execute_code:stateful:v2:agent-user:child';
|
|
const parentKey = 'execute_code:stateful:v2:user:shared';
|
|
const child: CodeFilesAgent = {
|
|
codeEnvAvailable: true,
|
|
codeExecutionContext: statefulContext(childKey),
|
|
codeSessionKey: childKey,
|
|
};
|
|
|
|
const routes = collectCodeExecutionProfileRoutes([
|
|
{
|
|
codeEnvAvailable: true,
|
|
codeExecutionContext: statelessContext,
|
|
codeSessionKey: Constants.EXECUTE_CODE,
|
|
},
|
|
{
|
|
codeEnvAvailable: true,
|
|
codeExecutionContext: statefulContext(parentKey),
|
|
codeSessionKey: parentKey,
|
|
subagentAgentConfigs: [child],
|
|
},
|
|
{ codeEnvAvailable: false, codeExecutionContext: statefulContext('ignored') },
|
|
]);
|
|
|
|
expect(routes).toEqual([
|
|
{
|
|
codeExecutionContext: statelessContext,
|
|
codeSessionKeys: [Constants.EXECUTE_CODE],
|
|
},
|
|
{
|
|
codeExecutionContext: statefulContext(parentKey),
|
|
codeSessionKeys: [parentKey, childKey],
|
|
},
|
|
]);
|
|
});
|
|
|
|
it('includes execution routes used only by graph-subagent members', () => {
|
|
const graphKey = 'execute_code:stateful:v2:user:graph-member';
|
|
const graphContext = {
|
|
baseUrl: 'https://stateful.example.com/v1',
|
|
codeSessionKey: graphKey,
|
|
executionProfile: 'stateful' as const,
|
|
runtimeSessionHint: 'v2:user:graph-member',
|
|
statefulSessions: true,
|
|
};
|
|
|
|
const routes = collectCodeExecutionProfileRoutes([
|
|
{
|
|
id: 'parent',
|
|
codeEnvAvailable: false,
|
|
subagentGraphConfigs: [
|
|
{
|
|
memberConfigs: [
|
|
{
|
|
id: 'graph-member',
|
|
codeEnvAvailable: true,
|
|
codeExecutionContext: graphContext,
|
|
codeSessionKey: graphKey,
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
]);
|
|
|
|
expect(routes).toEqual([{ codeExecutionContext: graphContext, codeSessionKeys: [graphKey] }]);
|
|
});
|
|
|
|
it('derives and includes the trusted profile for a lazy subagent descriptor', () => {
|
|
process.env.LIBRECHAT_CODE_BASEURL_STATEFUL = 'https://stateful.example.com/v1';
|
|
const routes = collectCodeExecutionProfileRoutes(
|
|
[
|
|
{
|
|
id: 'parent',
|
|
codeEnvAvailable: false,
|
|
lazySubagentConfigs: [
|
|
{
|
|
id: 'lazy-child',
|
|
codeEnvAvailable: true,
|
|
statefulCodeSessions: true,
|
|
statefulCodeEnvironment: 'agent-user',
|
|
},
|
|
],
|
|
},
|
|
],
|
|
{ userId: 'user-1', conversationId: 'conversation-1' },
|
|
);
|
|
|
|
expect(routes).toHaveLength(1);
|
|
expect(routes[0].codeExecutionContext).toEqual(
|
|
expect.objectContaining({
|
|
executionProfile: 'stateful',
|
|
statefulSessions: true,
|
|
}),
|
|
);
|
|
expect(routes[0].codeSessionKeys).toEqual([
|
|
expect.stringMatching(/^execute_code:stateful:v2:agent-user:/),
|
|
]);
|
|
delete process.env.LIBRECHAT_CODE_BASEURL_STATEFUL;
|
|
});
|
|
});
|