import { createReplyReferencePlanner, isSingleUseReplyToMode } from "./reply-reference.js";

import {

extractShortModelName,

hasTemplateVariables,

resolveResponsePrefixTemplate,

} from "./response-prefix-template.js";

import {

}

});

});

describe("hasTemplateVariables", () => {

it("handles empty, static, and repeated variable checks", () => {

expect(hasTemplateVariables("")).toBe(false);

expect(hasTemplateVariables("[{model}]")).toBe(true);

expect(hasTemplateVariables("[{model}]")).toBe(true);

expect(hasTemplateVariables("[Claude]")).toBe(false);

});

});

// Strip date suffixes (YYYYMMDD format)

return modelPart.replace(/-\d{8}$/, "").replace(/-latest$/, "");

}

/**

* Check if a template string contains any template variables.

*/

export function hasTemplateVariables(template: string | undefined): boolean {

if (!template) {

return false;

}

// Reset lastIndex since we're using a global regex

TEMPLATE_VAR_PATTERN.lastIndex = 0;

return TEMPLATE_VAR_PATTERN.test(template);

}

});

}

export function listBundledChannelSetupPluginsByFeature(

feature: keyof NonNullable<BundledChannelSetupEntryRuntimeContract["features"]>,

options: { config?: OpenClawConfig } = {},

): readonly ChannelPlugin[] {

const { rootScope, loadContext } = resolveActiveBundledChannelLoadScope();

return listBundledChannelPluginIdsForSetupFeature(rootScope, feature, {

config: options.config,

}).flatMap((id) => {

const setupEntry = getLazyGeneratedBundledChannelSetupEntryForRoot(id, rootScope, loadContext);

if (!hasSetupEntryFeature(setupEntry, feature)) {

return [];

}

const plugin = getBundledChannelSetupPluginForRoot(id, rootScope, loadContext);

return plugin ? [plugin] : [];

});

}

export function listBundledChannelLegacySessionSurfaces(

options: {

config?: OpenClawConfig;

routeFromBindingRecord,

routeFromConversationRef,

routeFromDeliveryContext,

routeFromSessionEntry,

routeToDeliveryFields,

routesShareDeliveryTarget,

} from "./route-projection.js";

describe("channel route projection", () => {

});

});

it("uses session route before legacy last route fields", () => {

expect(

routeFromSessionEntry({

sessionId: "sess-1",

updatedAt: 1,

route: {

channel: "slack",

target: { to: "channel:C123" },

thread: { id: "177000.123" },

},

deliveryContext: {

channel: "discord",

to: "channel:old",

threadId: "old-thread",

},

lastChannel: "discord",

lastTo: "channel:older",

}),

).toEqual({

channel: "slack",

target: { to: "channel:C123" },

thread: { id: "177000.123" },

});

});

it("narrows only routable routes and compares delivery targets", () => {

it("narrows only routable routes", () => {

expect(normalizeRoutableChannelRoute({ channel: "slack" })).toBeUndefined();

expect(

routesShareDeliveryTarget({

left: { channel: "slack", target: { to: "channel:C123" } },

right: {

channel: "slack",

accountId: "work",

target: { to: "channel:C123" },

},

}),

).toBe(true);

expect(

routesShareDeliveryTarget({

left: {

channel: "slack",

target: { to: "channel:C123" },

thread: { id: "thread-a" },

},

right: {

channel: "slack",

target: { to: "channel:C123" },

thread: { id: "thread-b" },

},

}),

).toBe(false);

});

});

// Route projection helpers between sessions, delivery context, and channel routes.

import type { SessionEntry } from "../config/sessions/types.js";

import type {

ConversationRef,

SessionBindingRecord,

} from "../infra/outbound/session-binding-service.js";

import {

channelRouteThreadId,

channelRouteTarget,

normalizeChannelRouteRef,

type ChannelRouteChatType,

type ChannelRouteRef,

import {

channelRouteFromDeliveryContext,

deliveryContextFromChannelRoute,

deliveryContextFromSession,

normalizeDeliveryContext,

normalizeSessionDeliveryFields,

type DeliveryContext,

} from "../utils/delivery-context.shared.js";

import { getChannelPlugin, normalizeChannelId } from "./plugins/registry.js";

return deliveryContextFromChannelRoute(route);

}

/** Projects the best known delivery route from a stored session entry. */

export function routeFromSessionEntry(entry?: SessionEntry | null): ChannelRouteRef | undefined {

if (!entry) {

return undefined;

}

return (

normalizeSessionDeliveryFields(entry).route ??

routeFromDeliveryContext(deliveryContextFromSession(entry))

);

}

/** Converts a persisted conversation reference into a channel route. */

export function routeFromConversationRef(

conversation?: ConversationRef | null,

...(deliveryContext?.threadId != null ? { threadId: deliveryContext.threadId } : {}),

};

}

/** Compares whether two routes address the same delivery target. */

export function routesShareDeliveryTarget(params: {

left?: ChannelRouteRef | null;

right?: ChannelRouteRef | null;

}): boolean {

const left = normalizeRoutableChannelRoute(params.left);

const right = normalizeRoutableChannelRoute(params.right);

if (!left || !right) {

return false;

}

return (

left.channel === right.channel &&

channelRouteTarget(left) === channelRouteTarget(right) &&

// Missing account ids are wildcards; thread ids must match when present.

(left.accountId == null || right.accountId == null || left.accountId === right.accountId) &&

String(channelRouteThreadId(left) ?? "") === String(channelRouteThreadId(right) ?? "")

);

}

// Sender label tests cover display-label formatting for channel senders.

import { describe, expect, it } from "vitest";

import { listSenderLabelCandidates, resolveSenderLabel } from "./sender-label.js";

import { resolveSenderLabel } from "./sender-label.js";

describe("resolveSenderLabel", () => {

it("prefers display + identifier when both are available", () => {

).toBeNull();

});

});

describe("listSenderLabelCandidates", () => {

it("returns unique normalized candidates plus resolved label", () => {

expect(

listSenderLabelCandidates({

name: "Alice",

username: "alice",

tag: "alice",

e164: "+15551234567",

id: "user-123",

}),

).toEqual(["Alice", "alice", "+15551234567", "user-123", "Alice (+15551234567)"]);

});

});

}

return display || idPart || null;

}

/** Returns de-duplicated sender label candidates for matching and search. */

export function listSenderLabelCandidates(params: SenderLabelParams): string[] {

const candidates = new Set<string>();

const { name, username, tag, e164, id } = normalizeSenderLabelParams(params);

if (name) {

candidates.add(name);

}

if (username) {

candidates.add(username);

}

if (tag) {

candidates.add(tag);

}

if (e164) {

candidates.add(e164);

}

if (id) {

candidates.add(id);

}

const resolved = resolveSenderLabel(params);

if (resolved) {

candidates.add(resolved);

}

return Array.from(candidates);

}

detectTelegramAllowFromMigration({ cfg, env }),

() => mockedChannelMigrationPlans.plans,

]),

listBundledChannelSetupPluginsByFeature: vi.fn((feature: string) => {

if (feature === "legacySessionSurfaces") {

return [

{

id: "whatsapp",

messaging: {

isLegacyGroupSessionKey: (key: string) => /^group:.+@g\.us$/i.test(key.trim()),

canonicalizeLegacySessionKey: ({ key, agentId }: { key: string; agentId: string }) =>

/^group:.+@g\.us$/i.test(key.trim())

? `agent:${agentId}:whatsapp:${key.trim().toLowerCase()}`

: null,

},

},

];

}

if (feature === "legacyStateMigrations") {

return [

{

id: "whatsapp",

lifecycle: {

detectLegacyStateMigrations: ({ oauthDir }: { oauthDir: string }) =>

detectWhatsAppLegacyStateMigrations({ oauthDir }),

},

},

{

id: "telegram",

lifecycle: {

detectLegacyStateMigrations: ({

cfg,

env,

}: {

cfg: OpenClawConfig;

env: NodeJS.ProcessEnv;

}) => detectTelegramAllowFromMigration({ cfg, env }),

},

},

];

}

return [];

}),

};

});