Enhanced ChatGPT Clone: Features Agents, MCP, Skills, DeepSeek, Anthropic, AWS, OpenAI, Responses API, Azure, Groq, o1, GPT-5, Mistral, OpenRouter, Vertex AI, Gemini, Artifacts, AI model switching, message search, Code Interpreter, langchain, DALL-E-3, OpenAPI Actions, Functions, Secure Multi-User Auth, Presets, open-source for self-hosting. Active
TypeScript aianthropicartifactsawsazurechatgptchatgpt-cloneclaudeclonedeepseekgeminigooglegpt-5librechatmcpo1openairesponses-apivisionwebui
import type { SteerQueueItem, SteerReceiptInput } from '../interfaces/IJobStore';
import { InMemoryJobStore } from '../implementations/InMemoryJobStore';
function steer(id: string): SteerQueueItem {
return {
steerId: id,
clientSteerId: `client-${id}`,
text: `text-${id}`,
userId: 'user-1',
createdAt: Date.now(),
};
}
function receipt(item: SteerQueueItem, createdAt: number): SteerReceiptInput {
return {
clientSteerId: item.clientSteerId!,
fingerprint: `fingerprint-${item.steerId}`,
userId: item.userId,
generationCreatedAt: createdAt,
};
}
describe('generation protocol rollout storage', () => {
test('in-memory defaults to v2 while an explicit v1 omits checkpoint isolation', async () => {
const store = new InMemoryJobStore();
const v2 = await store.createJob('protocol-v2', 'user-1');
const v1 = await store.createJob('protocol-v1', 'user-1', undefined, undefined, {
generationProtocolVersion: 1,
});
expect(v2.generationProtocolVersion).toBe(2);
expect(v2.checkpointNamespace).toEqual(expect.any(String));
expect(v2.checkpointNamespace).not.toBe(String(v2.createdAt));
expect(v1.generationProtocolVersion).toBe(1);
expect(v1.checkpointNamespace).toBeUndefined();
});
test('jobs receive distinct globally unique checkpoint scopes under a frozen clock', async () => {
const now = jest.spyOn(Date, 'now').mockReturnValue(1_000);
try {
const store = new InMemoryJobStore();
const first = await store.createJob('stream-a', 'owner-a', 'shared-conversation', undefined, {
providerExecutionId: 'shared-execution',
});
const second = await store.createJob(
'stream-b',
'owner-b',
'shared-conversation',
undefined,
{
providerExecutionId: 'shared-execution',
},
);
expect(second.createdAt).toBeGreaterThan(first.createdAt);
expect(first.checkpointNamespace).not.toBe(second.checkpointNamespace);
expect(first.checkpointNamespace).toMatch(/^lcg:v2:[0-9a-f]{64}:[0-9a-f-]{36}$/);
expect(second.checkpointNamespace).toMatch(/^lcg:v2:[0-9a-f]{64}:[0-9a-f-]{36}$/);
} finally {
now.mockRestore();
}
});
test('v1 steering stays receiptless and uses the legacy destructive drain', async () => {
const store = new InMemoryJobStore();
const job = await store.createJob('protocol-v1-steer', 'user-1', undefined, undefined, {
generationProtocolVersion: 1,
preemptCapable: true,
});
const item = steer('v1');
const enqueued = await store.enqueueSteerWithReceipt(
job.streamId,
item,
receipt(item, job.createdAt),
true,
job.createdAt,
);
expect(enqueued).toMatchObject({ position: 1, item: { steerId: item.steerId } });
expect(enqueued).not.toHaveProperty('state');
expect(await store.getSteerReceipt(job.streamId, item.clientSteerId!)).toBeNull();
const drained = await store.drainSteers(job.streamId, job.createdAt);
expect(drained).toHaveLength(1);
expect(await store.peekClaimedSteers(job.streamId, job.createdAt)).toEqual([]);
expect(
await store.appendChunk(job.streamId, { event: 'chunk' }, job.createdAt, drained[0]),
).toBe(true);
});
test('a v1 requester destructively downgrades even a v2 parked envelope', async () => {
const store = new InMemoryJobStore();
const job = await store.createJob('protocol-park-downgrade', 'user-1');
await store.parkSteers(
job.streamId,
JSON.stringify({
userId: 'user-1',
steers: [{ steerId: 'parked', text: 'keep me', createdAt: Date.now() }],
}),
job.createdAt,
);
const replayable = await store.claimParkedSteersDetailed(job.streamId, 'user-1', undefined, 2);
expect(replayable?.generationProtocolVersion).toBe(2);
expect(
await store.claimParkedSteersDetailed(job.streamId, 'user-1', undefined, 2),
).toBeDefined();
const downgraded = await store.claimParkedSteersDetailed(job.streamId, 'user-1', undefined, 1);
expect(downgraded?.generationProtocolVersion).toBe(1);
expect(JSON.parse(downgraded!.payload)).toMatchObject({ generationProtocolVersion: 1 });
expect(
await store.claimParkedSteersDetailed(job.streamId, 'user-1', undefined, 2),
).toBeUndefined();
});
test('a v1 requester takes only unleased leftovers during an active v2 recovery', async () => {
const store = new InMemoryJobStore();
const streamId = 'protocol-park-active-v2-lease';
const job = await store.createJob(streamId, 'user-1', undefined, undefined, {
generationProtocolVersion: 2,
});
const leased = { steerId: 'leased-v2', text: 'leased words', createdAt: 1 };
const legacy = { steerId: 'visible-v1', text: 'legacy words', createdAt: 2 };
await store.parkSteers(
streamId,
JSON.stringify({ userId: 'user-1', steers: [leased, legacy] }),
job.createdAt,
);
const recovery = await store.createJob(
streamId,
'user-1',
undefined,
undefined,
{ generationProtocolVersion: 2 },
leased.steerId,
undefined,
undefined,
undefined,
{ text: leased.text, fileIds: [], quotes: [] },
);
const downgraded = await store.claimParkedSteersDetailed(streamId, 'user-1', undefined, 1);
expect(downgraded?.generationProtocolVersion).toBe(1);
expect(JSON.parse(downgraded!.payload)).toEqual({
userId: 'user-1',
generationProtocolVersion: 1,
steers: [legacy],
});
await expect(
store.claimParkedSteersDetailed(streamId, 'user-1', undefined, 2),
).resolves.toBeUndefined();
await expect(
store.transitionStatus(streamId, {
from: 'running',
to: 'error',
expectCreatedAt: recovery.createdAt,
patch: { error: 'recovery failed', completedAt: Date.now() },
}),
).resolves.toBe(true);
const exposed = await store.claimParkedSteersDetailed(streamId, 'user-1', undefined, 2);
expect(JSON.parse(exposed!.payload)).toEqual({
userId: 'user-1',
generationProtocolVersion: 2,
steers: [leased],
});
});
test('a v1 parked envelope remains destructive for a v2 requester', async () => {
const store = new InMemoryJobStore();
const job = await store.createJob('protocol-park-v1', 'user-1', undefined, undefined, {
generationProtocolVersion: 1,
});
await store.parkSteers(
job.streamId,
JSON.stringify({
userId: 'user-1',
steers: [{ steerId: 'legacy', text: 'legacy words', createdAt: Date.now() }],
}),
job.createdAt,
);
expect(
(await store.claimParkedSteersDetailed(job.streamId, 'user-1', undefined, 2))
?.generationProtocolVersion,
).toBe(1);
expect(
await store.claimParkedSteersDetailed(job.streamId, 'user-1', undefined, 2),
).toBeUndefined();
});
test('cannot upgrade a v1 parked item into the v2 lease protocol implicitly', async () => {
const store = new InMemoryJobStore();
const streamId = 'protocol-v1-source';
const job = await store.createJob(streamId, 'user-1', undefined, undefined, {
generationProtocolVersion: 1,
});
await store.parkSteers(
streamId,
JSON.stringify({
userId: 'user-1',
steers: [{ steerId: 'legacy', text: 'legacy words', createdAt: Date.now() }],
}),
job.createdAt,
);
await expect(
store.createJob(
streamId,
'user-1',
undefined,
undefined,
{ generationProtocolVersion: 2 },
'legacy',
undefined,
undefined,
undefined,
{ text: 'legacy words', fileIds: [], quotes: [] },
),
).rejects.toMatchObject({ code: 'RECOVERY_PAYLOAD_MISMATCH' });
});
test('marks a token-owned idempotency bridge key started idempotently', async () => {
const store = new InMemoryJobStore();
await store.claimIdempotencyKey(
'legacy:user:req',
{ streamId: 'stream-1', conversationId: 'stream-1', claimToken: 'token-1' },
60,
);
expect(await store.markIdempotencyKeyStarted('legacy:user:req', 'token-1', 1234, 60)).toBe(
true,
);
expect(await store.markIdempotencyKeyStarted('legacy:user:req', 'token-1', 1234, 60)).toBe(
true,
);
expect(await store.markIdempotencyKeyStarted('legacy:user:req', 'token-1', 1235, 60)).toBe(
false,
);
});
});