- `messaging.targetResolver.looksLikeId(raw, normalized)` tells core whether an

input should skip straight to id-like resolution instead of directory search.

- `messaging.targetResolver.reservedLiterals` lists bare words that are

channel/session references for that provider and must fail closed before

directory or default-target fallback.

channel/session references for that provider. Resolution preserves configured

directory entries before rejecting reserved literals, then fails closed on a

directory miss.

- `messaging.targetResolver.resolveTarget(...)` is the plugin fallback when

core needs a final provider-owned resolution after normalization or after a

directory miss.

expect(plan.resolvedTo).toBe("1470130713209602050");

});

it("carries explicit target resolution errors from session-route preparation", async () => {

const targetResolutionError = new Error('reserved target "current"');

it("defers reserved-literal errors to async session-route resolution", async () => {

mocks.resolveOutboundChannelPlugin.mockReturnValue({

messaging: { resolveOutboundSessionRoute: vi.fn() },

});

mocks.resolveOutboundTarget.mockReturnValueOnce({

ok: false,

error: targetResolutionError,

error: new Error('Reserved target "current" for Telegram'),

});

const plan = await resolveAgentDeliveryPlanWithSessionRoute({

wantsDelivery: true,

});

expect(mocks.resolveOutboundSessionRoute).not.toHaveBeenCalled();

// Reserved-literal errors do not block session route resolution; the

// async resolver (resolveMessagingTarget) does directory-first lookup

// before rejecting reserved literals.

expect(mocks.resolveOutboundSessionRoute).toHaveBeenCalled();

expect(plan.resolvedTo).toBe("current");

expect(plan.targetResolutionError).toBe(targetResolutionError);

expect(plan.targetResolutionError).toBeUndefined();

});

it("surfaces stored explicit target errors even when explicit validation is disabled", () => {

accountId: plan.resolvedAccountId,

mode: plan.deliveryTargetMode ?? "explicit",

});

if (!normalizedTarget.ok) {

// Reserved-literal errors are not fatal for explicit delivery: the async

// session-route resolver (resolveChannelTarget → resolveMessagingTarget)

// does directory-first lookup before rejecting reserved literals, so a

// configured directory entry named like a reserved word still resolves.

const isReservedLiteralError =

!normalizedTarget.ok && normalizedTarget.error.message.includes("Reserved target");

if (!normalizedTarget.ok && !isReservedLiteralError) {

return { ...plan, targetResolutionError: normalizedTarget.error };

}

const sessionRouteTarget = normalizedTarget.ok ? normalizedTarget.to : (plan.resolvedTo ?? "");

const explicitThreadId =

params.explicitThreadId != null && params.explicitThreadId !== ""

? params.explicitThreadId

channel: plan.resolvedChannel as ChannelId,

agentId: params.agentId,

accountId: plan.resolvedAccountId,

target: normalizedTarget.to,

target: sessionRouteTarget,

currentSessionKey: params.currentSessionKey,

threadId: plan.deliveryTargetMode === "explicit" ? explicitThreadId : plan.resolvedThreadId,

});