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
🦭 test: Add Scheduled MCP Authorization Contract Fixtures (#16645)
lia-by-librechat[bot]76fac095312d
diff --git a/packages/api/src/schedules/authorization/conformance.helper.ts b/packages/api/src/schedules/authorization/conformance.helper.tsnew file mode 100644index 0000000000..8599e70291--- /dev/null+++ b/packages/api/src/schedules/authorization/conformance.helper.ts@@ -0,0 +1,62 @@+import type { ScheduledMCPAuthorizationRequest, ScheduledMCPAuthorizationResult } from './contract';+import type { AuthorizationFacts, AuthorizationFixture } from './fixtures.helper';+import { failureFixtures } from './fixtures.helper';++/** Test-only adapter: supply these snapshots through an implementation's injected dependencies. */+export type AuthorizationFixtureEvaluator = (+ request: ScheduledMCPAuthorizationRequest,+ facts: AuthorizationFacts,+ options: { signal: AbortSignal },+) => Promise<ScheduledMCPAuthorizationResult>;++/** Reuses the evaluator across fresh snapshots to expose stale authorization decisions. */+export async function verifyAuthorizationFixture(+ fixture: AuthorizationFixture,+ evaluate: AuthorizationFixtureEvaluator,+): Promise<void> {+ for (const step of fixture.steps) {+ const controller = new AbortController();+ if (step.aborted) controller.abort();+ const result = await evaluate(+ structuredClone({ ...fixture.request, stage: step.stage }),+ structuredClone(step.facts),+ { signal: controller.signal },+ );+ const fail = (): never => {+ throw new Error(`Authorization contract mismatch: ${fixture.id}/${step.stage}`);+ };+ if (step.expected === 'cancelled') {+ if (result.state !== 'cancelled') fail();+ continue;+ }+ if (step.expected !== 'authorized') {+ const expected = failureFixtures[step.expected];+ if (+ result.state !== 'denied' ||+ result.failure.reason !== expected.reason ||+ result.failure.status !== expected.status ||+ result.failure.recovery !== expected.recovery ||+ result.failure.automaticReplay !== false ||+ Object.keys(result.failure).length !== Object.keys(expected).length+ ) {+ fail();+ }+ continue;+ }+ if (result.state !== 'authorized' || step.facts.consent.state !== 'found') {+ fail();+ continue;+ }+ const consent = step.facts.consent.consent;+ if (+ result.consentId !== consent.id ||+ result.consentRevision !== consent.revision ||+ result.policyRevision !== step.facts.policyRevision ||+ !Number.isFinite(result.validUntilMs) ||+ result.validUntilMs <= step.facts.nowMs ||+ result.validUntilMs > consent.absoluteExpiresAtMs+ ) {+ fail();+ }+ }+}diff --git a/packages/api/src/schedules/authorization/conformance.spec.ts b/packages/api/src/schedules/authorization/conformance.spec.tsnew file mode 100644index 0000000000..f53f8e8823--- /dev/null+++ b/packages/api/src/schedules/authorization/conformance.spec.ts@@ -0,0 +1,107 @@+import { scheduleMCPOutcomeSchema } from 'librechat-data-provider';+import type { ScheduledMCPAuthorizationResult } from './contract';+import type { AuthorizationFixture } from './fixtures.helper';+import { authorizationFixtures, failureFixtures } from './fixtures.helper';+import { verifyAuthorizationFixture } from './conformance.helper';++/** Exercises the harness, not a production authorization implementation. */+function scriptedResults(fixture: AuthorizationFixture): ScheduledMCPAuthorizationResult[] {+ return fixture.steps.map((step) => {+ if (step.expected === 'cancelled') return { state: 'cancelled' };+ if (step.expected !== 'authorized') {+ return { state: 'denied', failure: failureFixtures[step.expected] };+ }+ if (step.facts.consent.state !== 'found') throw new Error('Invalid positive fixture');+ const consent = step.facts.consent.consent;+ return {+ state: 'authorized',+ consentId: consent.id,+ consentRevision: consent.revision,+ policyRevision: step.facts.policyRevision,+ validUntilMs: consent.absoluteExpiresAtMs,+ };+ });+}++it.each(authorizationFixtures)('accepts the complete scripted contract: $id', async (fixture) => {+ const results = scriptedResults(fixture);+ const evaluate = jest.fn(async () => results.shift()!);+ await verifyAuthorizationFixture(fixture, evaluate);+ expect(evaluate.mock.calls).toHaveLength(fixture.steps.length);+});++it.each(+ authorizationFixtures.filter((fixture) =>+ fixture.steps.some((step) => step.expected !== 'authorized'),+ ),+)('rejects an implementation that reuses an allow decision: $id', async (fixture) => {+ const evaluate = jest.fn(+ async (): Promise<ScheduledMCPAuthorizationResult> => ({+ state: 'authorized',+ consentId: 'consent-1',+ consentRevision: 'consent-revision-1',+ policyRevision: 'policy-1',+ validUntilMs: 10_000,+ }),+ );+ await expect(verifyAuthorizationFixture(fixture, evaluate)).rejects.toThrow(+ 'Authorization contract mismatch',+ );+});++it('rejects token expiry used to extend the consent deadline', async () => {+ const fixture = authorizationFixtures[0];+ const result = scriptedResults(fixture)[0];+ if (result.state !== 'authorized') throw new Error('Invalid positive fixture');+ await expect(+ verifyAuthorizationFixture(fixture, async () => ({ ...result, validUntilMs: 20_000 })),+ ).rejects.toThrow('Authorization contract mismatch');+});++it('rejects a stale policy revision', async () => {+ const fixture = authorizationFixtures[0];+ const result = scriptedResults(fixture)[0];+ if (result.state !== 'authorized') throw new Error('Invalid positive fixture');+ await expect(+ verifyAuthorizationFixture(fixture, async () => ({ ...result, policyRevision: 'old-policy' })),+ ).rejects.toThrow('Authorization contract mismatch');+});++it('does not permit automatic replay or an incompatible public failure status', () => {+ for (const failure of Object.values(failureFixtures)) {+ expect(failure.automaticReplay).toBe(false);+ expect(+ scheduleMCPOutcomeSchema.safeParse({ server: 'warehouse', status: failure.status }).success,+ ).toBe(true);+ }+});++it('requires unique vector IDs and explicit tenant bindings', () => {+ expect(new Set(authorizationFixtures.map((fixture) => fixture.id)).size).toBe(+ authorizationFixtures.length,+ );+ for (const fixture of authorizationFixtures) {+ expect(fixture.request.identity).toHaveProperty('tenantId');+ expect(fixture.steps.length).toBeGreaterThan(0);+ }+});++it('isolates dependency snapshots from a mutating test adapter', async () => {+ const fixture = authorizationFixtures[0];+ const results = scriptedResults(fixture);+ await verifyAuthorizationFixture(fixture, async (request, facts) => {+ Object.assign(request.identity, { agentId: 'tampered' });+ Object.assign(facts, { rbac: 'denied' });+ return results.shift()!;+ });+ expect(fixture.request.identity.agentId).toBe('root-agent');+ expect(fixture.steps[0].facts.rbac).toBe('allowed');+});++it('delivers cancellation to the adapter without inventing a reauth failure', async () => {+ const fixture = authorizationFixtures.find((item) => item.id === 'cancelled-before-admission')!;+ await verifyAuthorizationFixture(fixture, async (_request, _facts, { signal }) => {+ expect(signal.aborted).toBe(true);+ return { state: 'cancelled' };+ });+});diff --git a/packages/api/src/schedules/authorization/contract.ts b/packages/api/src/schedules/authorization/contract.tsnew file mode 100644index 0000000000..30946c9dfe--- /dev/null+++ b/packages/api/src/schedules/authorization/contract.ts@@ -0,0 +1,125 @@+import type { ScheduleMCPOutcome } from 'librechat-data-provider';+import type { ScheduledTokenContext } from '../context';++export type ScheduledMCPCredentialMode =+ | 'stored_oauth'+ | 'browser_bearer'+ | 'renewable_obo'+ | 'resource_bearer'+ | 'static'+ | 'anonymous';++/** agentId remains the enrolled root, including during child execution. */+export interface ScheduledMCPIdentity extends Omit<ScheduledTokenContext, 'tenantId'> {+ readonly tenantId: string | null;+}++/** Resolved by trusted configuration, never by model arguments or token scopes. */+export interface ScheduledMCPResource {+ readonly serverName: string;+ readonly url: string;+ readonly configurationRevision: string;+ readonly credentialMode: ScheduledMCPCredentialMode;+ readonly issuer: string | null;+ readonly audience: string | null;+ readonly scopes: readonly string[];+}++export interface ScheduledMCPToolSelection {+ readonly agentId: string;+ readonly tools: readonly string[];+}++export interface ScheduledMCPConsent {+ readonly id: string;+ readonly revision: string;+ readonly identity: ScheduledMCPIdentity;+ readonly resource: ScheduledMCPResource;+ readonly permittedTools: readonly ScheduledMCPToolSelection[];+ readonly policyRevision: string;+ readonly grantedAtMs: number;+ /** Fixed consent deadline; credential renewal cannot extend it. */+ readonly absoluteExpiresAtMs: number;+ readonly revokedAtMs: number | null;+}++export type ScheduledMCPFailureReason =+ | 'consent_missing'+ | 'consent_expired'+ | 'consent_revoked'+ | 'binding_mismatch'+ | 'rbac_denied'+ | 'tool_policy_denied'+ | 'approval_required'+ | 'credential_missing'+ | 'credential_rejected'+ | 'resource_permission_denied'+ | 'provider_missing'+ | 'resource_unverified'+ | 'unsupported_mode'+ | 'dependency_unavailable';++/** Safe diagnosis projected onto existing schedule statuses. */+export interface ScheduledMCPFailure {+ readonly reason: ScheduledMCPFailureReason;+ readonly status: Exclude<ScheduleMCPOutcome['status'], 'ready'>;+ readonly recovery: 'authorize' | 'configure' | 'restore_permission' | 'retry_later';+ readonly automaticReplay: false;+}++export type ScheduledMCPConsentLookupResult =+ | { readonly state: 'found'; readonly consent: ScheduledMCPConsent }+ | { readonly state: 'missing' }+ | { readonly state: 'unavailable' };++export interface ScheduledMCPAuthorizationRequest {+ readonly identity: ScheduledMCPIdentity;+ readonly resource: ScheduledMCPResource;+ readonly stage: 'activation' | 'mint' | 'invoke' | 'resume';+ readonly selection: ScheduledMCPToolSelection;+}++/** Ephemeral observation, not a transferable grant or permission to cache an allow decision. */+export type ScheduledMCPAuthorizationResult =+ | {+ readonly state: 'authorized';+ readonly consentId: string;+ readonly consentRevision: string;+ readonly policyRevision: string;+ readonly validUntilMs: number;+ }+ | { readonly state: 'denied'; readonly failure: ScheduledMCPFailure }+ | { readonly state: 'cancelled' };++export interface ScheduledMCPAuthority {+ readonly lookupConsent: (+ identity: ScheduledMCPIdentity,+ resource: ScheduledMCPResource,+ options: { signal?: AbortSignal },+ ) => Promise<ScheduledMCPConsentLookupResult>;+ /** Rechecks live consent, RBAC, schedule/graph binding and trusted tool policy at each stage. */+ readonly authorize: (+ request: ScheduledMCPAuthorizationRequest,+ options: { signal?: AbortSignal },+ ) => Promise<ScheduledMCPAuthorizationResult>;+}++export type ScheduledMCPBearerResult =+ | {+ readonly state: 'ready';+ readonly accessToken: string;+ readonly expiresAtMs: number;+ readonly issuer: string;+ readonly audience: string;+ readonly resourceUrl: string;+ }+ | { readonly state: 'denied'; readonly failure: ScheduledMCPFailure }+ | { readonly state: 'cancelled' };++/** Resolves a resource-bound bearer after live authorization; use must reauthorize. */+export type ScheduledMCPResourceBearerResolver = (+ request: ScheduledMCPAuthorizationRequest & {+ readonly resource: ScheduledMCPResource & { readonly credentialMode: 'resource_bearer' };+ },+ options: { signal?: AbortSignal },+) => Promise<ScheduledMCPBearerResult>;diff --git a/packages/api/src/schedules/authorization/fixtures.helper.ts b/packages/api/src/schedules/authorization/fixtures.helper.tsnew file mode 100644index 0000000000..e59ce2371d--- /dev/null+++ b/packages/api/src/schedules/authorization/fixtures.helper.ts@@ -0,0 +1,352 @@+import type {+ ScheduledMCPConsent,+ ScheduledMCPFailure,+ ScheduledMCPIdentity,+ ScheduledMCPResource,+ ScheduledMCPConsentLookupResult,+ ScheduledMCPAuthorizationRequest,+} from './contract';++export interface AuthorizationFacts {+ readonly nowMs: number;+ readonly consent: ScheduledMCPConsentLookupResult;+ readonly rbac: 'allowed' | 'denied' | 'unavailable';+ readonly scheduleActive: boolean;+ readonly graphAgentIds: readonly string[];+ readonly policyRevision: string;+ readonly classifications: readonly {+ agentId: string;+ tool: string;+ effect: 'read' | 'write' | 'unknown';+ source: 'host' | 'server_hint';+ }[];+ readonly approvalRequired: boolean;+ readonly providerInstalled: boolean;+ readonly resourceAcceptanceVerified: boolean;+}++export interface AuthorizationStep {+ readonly stage: ScheduledMCPAuthorizationRequest['stage'];+ readonly facts: AuthorizationFacts;+ readonly expected: 'authorized' | 'cancelled' | ScheduledMCPFailure['reason'];+ readonly aborted?: boolean;+}++export interface AuthorizationFixture {+ readonly id: string;+ readonly request: Omit<ScheduledMCPAuthorizationRequest, 'stage'>;+ readonly steps: readonly AuthorizationStep[];+}++const identity: ScheduledMCPIdentity = {+ scheduleId: 'schedule-1',+ ownerId: 'owner-1',+ tenantId: 'tenant-1',+ agentId: 'root-agent',+ invocationMode: 'delegated',+};+const resource: ScheduledMCPResource = {+ serverName: 'warehouse',+ url: 'https://warehouse.example/mcp',+ configurationRevision: 'configuration-1',+ credentialMode: 'resource_bearer',+ issuer: 'https://issuer.example/',+ audience: 'warehouse-api',+ scopes: ['query.read'],+};+const consent: ScheduledMCPConsent = {+ id: 'consent-1',+ revision: 'consent-revision-1',+ identity,+ resource,+ permittedTools: [+ { agentId: 'root-agent', tools: ['query'] },+ { agentId: 'child-agent', tools: ['query'] },+ ],+ policyRevision: 'policy-1',+ grantedAtMs: 1_000,+ absoluteExpiresAtMs: 10_000,+ revokedAtMs: null,+};+const facts: AuthorizationFacts = {+ nowMs: 2_000,+ consent: { state: 'found', consent },+ rbac: 'allowed',+ scheduleActive: true,+ graphAgentIds: ['root-agent', 'child-agent'],+ policyRevision: 'policy-1',+ classifications: [+ { agentId: 'root-agent', tool: 'query', effect: 'read', source: 'host' },+ { agentId: 'child-agent', tool: 'query', effect: 'read', source: 'host' },+ ],+ approvalRequired: false,+ providerInstalled: true,+ resourceAcceptanceVerified: true,+};+const request: AuthorizationFixture['request'] = {+ identity,+ resource,+ selection: { agentId: 'root-agent', tools: ['query'] },+};+const stages: readonly AuthorizationStep['stage'][] = ['activation', 'mint', 'invoke', 'resume'];++function fixture(+ id: string,+ expected: AuthorizationStep['expected'],+ currentFacts: AuthorizationFacts = facts,+ currentRequest: AuthorizationFixture['request'] = request,+): AuthorizationFixture {+ return {+ id,+ request: currentRequest,+ steps: stages.map((stage) => ({ stage, facts: currentFacts, expected })),+ };+}++function changedConsent(change: Partial<ScheduledMCPConsent>): AuthorizationFacts {+ return { ...facts, consent: { state: 'found', consent: { ...consent, ...change } } };+}++export const authorizationFixtures: readonly AuthorizationFixture[] = [+ fixture('bound-root', 'authorized'),+ fixture('bound-child', 'authorized', facts, {+ ...request,+ selection: { agentId: 'child-agent', tools: ['query'] },+ }),+ fixture(+ 'single-tenant',+ 'authorized',+ changedConsent({ identity: { ...identity, tenantId: null } }),+ {+ ...request,+ identity: { ...identity, tenantId: null },+ },+ ),+ fixture('missing-consent', 'consent_missing', { ...facts, consent: { state: 'missing' } }),+ fixture('consent-store-outage', 'dependency_unavailable', {+ ...facts,+ consent: { state: 'unavailable' },+ }),+ fixture('just-before-deadline', 'authorized', { ...facts, nowMs: 9_999 }),+ fixture('expired-at-deadline', 'consent_expired', { ...facts, nowMs: 10_000 }),+ fixture('expired-after-deadline', 'consent_expired', { ...facts, nowMs: 10_001 }),+ fixture(+ 'nonfinite-deadline',+ 'binding_mismatch',+ changedConsent({ absoluteExpiresAtMs: Number.NaN }),+ ),+ fixture(+ 'deadline-before-grant',+ 'binding_mismatch',+ changedConsent({ absoluteExpiresAtMs: 500 }),+ ),+ fixture('revoked', 'consent_revoked', changedConsent({ revokedAtMs: 1_999 })),+ ...(['scheduleId', 'ownerId', 'tenantId', 'agentId'] as const).map((key) =>+ fixture(`changed-${key}`, 'binding_mismatch', facts, {+ ...request,+ identity: { ...identity, [key]: 'different' },+ }),+ ),+ fixture('missing-tenant-is-not-a-match', 'binding_mismatch', facts, {+ ...request,+ identity: { ...identity, tenantId: null },+ }),+ ...(['url', 'configurationRevision', 'issuer', 'audience', 'serverName'] as const).map((key) =>+ fixture(`changed-${key}`, 'binding_mismatch', facts, {+ ...request,+ resource: { ...resource, [key]: 'different' },+ }),+ ),+ fixture('changed-scopes', 'binding_mismatch', facts, {+ ...request,+ resource: { ...resource, scopes: ['query.read', 'query.write'] },+ }),+ fixture('changed-mode', 'binding_mismatch', facts, {+ ...request,+ resource: { ...resource, credentialMode: 'renewable_obo' },+ }),+ fixture('revoked-rbac', 'rbac_denied', { ...facts, rbac: 'denied' }),+ fixture('rbac-store-outage', 'dependency_unavailable', { ...facts, rbac: 'unavailable' }),+ fixture('inactive-schedule', 'binding_mismatch', { ...facts, scheduleActive: false }),+ fixture(+ 'child-no-longer-reachable',+ 'binding_mismatch',+ {+ ...facts,+ graphAgentIds: ['root-agent'],+ },+ { ...request, selection: { agentId: 'child-agent', tools: ['query'] } },+ ),+ fixture('changed-trusted-policy', 'binding_mismatch', { ...facts, policyRevision: 'policy-2' }),+ fixture('empty-tool-selection', 'tool_policy_denied', facts, {+ ...request,+ selection: { agentId: 'root-agent', tools: [] },+ }),+ fixture('new-tool-not-enrolled', 'tool_policy_denied', facts, {+ ...request,+ selection: { agentId: 'root-agent', tools: ['query', 'delete'] },+ }),+ ...(['write', 'unknown'] as const).map((effect) =>+ fixture(`tool-effect-${effect}`, 'tool_policy_denied', {+ ...facts,+ classifications: [{ agentId: 'root-agent', tool: 'query', effect, source: 'host' }],+ }),+ ),+ fixture('server-readonly-hint-is-not-authority', 'tool_policy_denied', {+ ...facts,+ classifications: [+ { agentId: 'root-agent', tool: 'query', effect: 'read', source: 'server_hint' },+ ],+ }),+ fixture('unclassified-tool', 'tool_policy_denied', { ...facts, classifications: [] }),+ fixture('approval-needed-headlessly', 'approval_required', { ...facts, approvalRequired: true }),+ fixture('missing-provider', 'provider_missing', { ...facts, providerInstalled: false }),+ fixture('resource-not-certified', 'resource_unverified', {+ ...facts,+ resourceAcceptanceVerified: false,+ }),+ fixture(+ 'browser-bearer-not-headless',+ 'unsupported_mode',+ changedConsent({ resource: { ...resource, credentialMode: 'browser_bearer' } }),+ { ...request, resource: { ...resource, credentialMode: 'browser_bearer' } },+ ),+ ...(['stored_oauth', 'renewable_obo', 'static', 'anonymous'] as const).map((credentialMode) => {+ const target = {+ ...resource,+ credentialMode,+ ...((credentialMode === 'static' || credentialMode === 'anonymous') && {+ issuer: null,+ audience: null,+ scopes: [],+ }),+ };+ return fixture(+ `candidate-${credentialMode}`,+ 'authorized',+ changedConsent({ resource: target }),+ {+ ...request,+ resource: target,+ },+ );+ }),+ {+ id: 'cancelled-before-admission',+ request,+ steps: stages.map((stage) => ({ stage, facts, expected: 'cancelled', aborted: true })),+ },+ {+ id: 'revocation-after-mint',+ request,+ steps: [+ { stage: 'mint', facts, expected: 'authorized' },+ {+ stage: 'invoke',+ facts: changedConsent({ revokedAtMs: 2_000 }),+ expected: 'consent_revoked',+ },+ {+ stage: 'resume',+ facts: changedConsent({ revokedAtMs: 2_000 }),+ expected: 'consent_revoked',+ },+ ],+ },+ {+ id: 'expiry-during-approval-pause',+ request,+ steps: [+ { stage: 'invoke', facts, expected: 'authorized' },+ { stage: 'resume', facts: { ...facts, nowMs: 10_000 }, expected: 'consent_expired' },+ ],+ },+];++export const failureFixtures: Readonly<Record<ScheduledMCPFailure['reason'], ScheduledMCPFailure>> =+ {+ consent_missing: {+ reason: 'consent_missing',+ status: 'mcp_reauth_required',+ recovery: 'authorize',+ automaticReplay: false,+ },+ consent_expired: {+ reason: 'consent_expired',+ status: 'mcp_reauth_required',+ recovery: 'authorize',+ automaticReplay: false,+ },+ consent_revoked: {+ reason: 'consent_revoked',+ status: 'mcp_reauth_required',+ recovery: 'authorize',+ automaticReplay: false,+ },+ binding_mismatch: {+ reason: 'binding_mismatch',+ status: 'mcp_reauth_required',+ recovery: 'authorize',+ automaticReplay: false,+ },+ rbac_denied: {+ reason: 'rbac_denied',+ status: 'mcp_permission_denied',+ recovery: 'restore_permission',+ automaticReplay: false,+ },+ tool_policy_denied: {+ reason: 'tool_policy_denied',+ status: 'mcp_permission_denied',+ recovery: 'configure',+ automaticReplay: false,+ },+ approval_required: {+ reason: 'approval_required',+ status: 'mcp_permission_denied',+ recovery: 'configure',+ automaticReplay: false,+ },+ credential_missing: {+ reason: 'credential_missing',+ status: 'mcp_reauth_required',+ recovery: 'authorize',+ automaticReplay: false,+ },+ credential_rejected: {+ reason: 'credential_rejected',+ status: 'mcp_reauth_required',+ recovery: 'authorize',+ automaticReplay: false,+ },+ resource_permission_denied: {+ reason: 'resource_permission_denied',+ status: 'mcp_permission_denied',+ recovery: 'restore_permission',+ automaticReplay: false,+ },+ provider_missing: {+ reason: 'provider_missing',+ status: 'mcp_configuration_missing',+ recovery: 'configure',+ automaticReplay: false,+ },+ resource_unverified: {+ reason: 'resource_unverified',+ status: 'mcp_configuration_missing',+ recovery: 'configure',+ automaticReplay: false,+ },+ unsupported_mode: {+ reason: 'unsupported_mode',+ status: 'mcp_configuration_missing',+ recovery: 'configure',+ automaticReplay: false,+ },+ dependency_unavailable: {+ reason: 'dependency_unavailable',+ status: 'mcp_unavailable',+ recovery: 'retry_later',+ automaticReplay: false,+ },+ };