const embeddedAgentMcp = loadEmbeddedAgentMcpConfig({

workspaceDir,

cfg: config,

manifestRegistry: metadataSnapshot.manifestRegistry,

});

for (const diagnostic of embeddedAgentMcp.diagnostics) {

log.warn(`bundle MCP skipped for ${diagnostic.pluginId}: ${diagnostic.message}`);

type BundleMcpDiagnostic,

type BundleMcpServerConfig,

} from "../plugins/bundle-mcp.js";

import type { PluginManifestRegistry } from "../plugins/manifest-registry.js";

type MergedBundleMcpConfig = {

config: BundleMcpConfig;

export function loadMergedBundleMcpConfig(params: {

workspaceDir: string;

cfg?: OpenClawConfig;

manifestRegistry?: Pick<PluginManifestRegistry, "plugins">;

mapConfiguredServer?: BundleMcpServerMapper;

}): MergedBundleMcpConfig {

const bundleMcp = loadEnabledBundleMcpConfig({

workspaceDir: params.workspaceDir,

cfg: params.cfg,

manifestRegistry: params.manifestRegistry,

});

const configuredMcp = normalizeConfiguredMcpServers(params.cfg?.mcp?.servers);

const mapConfiguredServer = params.mapConfiguredServer ?? ((server) => server);

import type { OpenClawConfig } from "../config/types.openclaw.js";

import type { BundleMcpDiagnostic, BundleMcpServerConfig } from "../plugins/bundle-mcp.js";

import type { PluginManifestRegistry } from "../plugins/manifest-registry.js";

import { loadMergedBundleMcpConfig } from "./bundle-mcp-config.js";

type EmbeddedAgentMcpConfig = {

export function loadEmbeddedAgentMcpConfig(params: {

workspaceDir: string;

cfg?: OpenClawConfig;

manifestRegistry?: Pick<PluginManifestRegistry, "plugins">;

}): EmbeddedAgentMcpConfig {

const bundleMcp = loadMergedBundleMcpConfig({

workspaceDir: params.workspaceDir,

cfg: params.cfg,

manifestRegistry: params.manifestRegistry,

});

return {

export async function updateSessionStoreEntry(params: {

storePath: string;

sessionKey: string;

update: (entry: SessionEntry) => Promise<Partial<SessionEntry> | null>;

update: (

entry: SessionEntry,

) => Promise<Partial<SessionEntry> | null> | Partial<SessionEntry> | null;

skipMaintenance?: boolean;

takeCacheOwnership?: boolean;

}): Promise<SessionEntry | null> {

});

});

it("uses single-entry persistence for ordinary gateway admission touches", async () => {

mockMainSessionEntry({});

let capturedOptions:

| {

resolveSingleEntryPersistence?: (result: unknown) => unknown;

}

| undefined;

let persistedResult: unknown;

mocks.updateSessionStore.mockImplementation(async (_path, updater, opts) => {

const store: Record<string, Record<string, unknown>> = {

"agent:main:main": buildExistingMainStoreEntry(),

};

persistedResult = await updater(store);

capturedOptions = opts;

return persistedResult;

});

mocks.agentCommand.mockResolvedValue({

payloads: [{ text: "ok" }],

meta: { durationMs: 100 },

});

await runMainAgent("hi", "idem-single-entry-persist");

expect(capturedOptions?.resolveSingleEntryPersistence?.(persistedResult)).toMatchObject({

sessionKey: "agent:main:main",

entry: persistedResult,

});

});

it("disables single-entry persistence when admission prunes legacy store keys", async () => {

mockMainSessionEntry({});

let capturedOptions:

| {

resolveSingleEntryPersistence?: (result: unknown) => unknown;

}

| undefined;

let persistedResult: unknown;

mocks.updateSessionStore.mockImplementation(async (_path, updater, opts) => {

const store: Record<string, Record<string, unknown>> = {

"agent:main:main": buildExistingMainStoreEntry({ updatedAt: 100 }),

"Agent:main:main": buildExistingMainStoreEntry({ updatedAt: 50 }),

};

persistedResult = await updater(store);

capturedOptions = opts;

return persistedResult;

});

mocks.agentCommand.mockResolvedValue({

payloads: [{ text: "ok" }],

meta: { durationMs: 100 },

});

await runMainAgent("hi", "idem-single-entry-legacy-prune");

expect(capturedOptions?.resolveSingleEntryPersistence?.(persistedResult)).toBeUndefined();

});

it("preserves ACP metadata from the current stored session entry", async () => {

const existingAcpMeta = {

backend: "acpx",

loadGatewaySessionRow,

loadSessionEntry,

migrateAndPruneGatewaySessionStoreKey,

resolveGatewaySessionStoreTarget,

resolveGatewayModelSupportsImages,

resolveSessionModelRef,

} from "../session-utils.js";

if (storePath && !suppressVisibleSessionEffects) {

const requestedStoreKey = requestedSessionKey;

let deniedBySendPolicy = false;

let singleEntryPersistence:

| {

sessionKey: string;

entry: SessionEntry;

}

| undefined;

const persisted = await updateSessionStore(

storePath,

(store) => {

const { primaryKey } = migrateAndPruneGatewaySessionStoreKey({

const storeKeysBeforeMigration = new Set(Object.keys(store));

const preMigrationTarget = resolveGatewaySessionStoreTarget({

cfg,

key: requestedStoreKey,

store,

});

const hadLegacyStoreKey = preMigrationTarget.storeKeys.some(

(storeKey) =>

storeKey !== preMigrationTarget.canonicalKey &&

Object.prototype.hasOwnProperty.call(store, storeKey),

);

const { target, primaryKey } = migrateAndPruneGatewaySessionStoreKey({

cfg,

key: requestedStoreKey,

store,

});

const prunedStoreKey = [...storeKeysBeforeMigration].some(

(storeKey) => !Object.prototype.hasOwnProperty.call(store, storeKey),

);

const freshEntry = store[primaryKey];

patchBuild = buildSessionPatch(freshEntry);

const effectivePatch =

return merged;

}

store[primaryKey] = merged;

const canonicalKeyChanged = target.canonicalKey !== preMigrationTarget.canonicalKey;

singleEntryPersistence =

freshEntry && !hadLegacyStoreKey && !canonicalKeyChanged && !prunedStoreKey

? {

sessionKey: primaryKey,

entry: merged,

}

: undefined;

return merged;

},

{ takeCacheOwnership: true, maintenanceConfig: sessionMaintenanceConfig },

{

takeCacheOwnership: true,

maintenanceConfig: sessionMaintenanceConfig,

resolveSingleEntryPersistence: () => singleEntryPersistence,

},

);

if (persisted) {

sessionEntry = persisted;

import { matchRootFileOpenFailure, type RootFileOpenFailure } from "../infra/boundary-file-read.js";

import { readRootJsonObjectSync } from "../infra/json-files.js";

import { normalizePluginsConfig, resolveEffectivePluginActivationState } from "./config-state.js";

import type { PluginManifestRegistry } from "./manifest-registry.js";

import type { PluginBundleFormat } from "./manifest-types.js";

import { loadPluginManifestRegistryForPluginRegistry } from "./plugin-registry.js";

export function loadEnabledBundleConfig<TConfig, TDiagnostic>(params: {

workspaceDir: string;

cfg?: OpenClawConfig;

manifestRegistry?: Pick<PluginManifestRegistry, "plugins">;

createEmptyConfig: () => TConfig;

loadBundleConfig: (params: {

pluginId: string;

return { config: params.createEmptyConfig(), diagnostics: [] };

}

const registry = loadPluginManifestRegistryForPluginRegistry({

workspaceDir: params.workspaceDir,

config: params.cfg,

includeDisabled: true,

});

const registry =

params.manifestRegistry ??

loadPluginManifestRegistryForPluginRegistry({

workspaceDir: params.workspaceDir,

config: params.cfg,

includeDisabled: true,

});

const diagnostics: TDiagnostic[] = [];

let merged = params.createEmptyConfig();

);

});

it("uses a provided manifest registry instead of rediscovering bundle plugins", async () => {

const homeDir = await tempHarness.createTempDir("openclaw-bundle-mcp-home-");

const workspaceDir = await tempHarness.createTempDir("openclaw-bundle-mcp-workspace-");

const { pluginRoot } = await createBundleProbePlugin(homeDir);

const loaded = loadEnabledBundleMcpConfig({

workspaceDir,

cfg: createEnabledBundleConfig(["bundle-probe"]),

manifestRegistry: {

plugins: [

{

id: "bundle-probe",

origin: "global",

format: "bundle",

bundleFormat: "claude",

channels: [],

providers: [],

cliBackends: [],

skills: [],

hooks: [],

rootDir: await fs.realpath(pluginRoot),

source: "test",

manifestPath: path.join(pluginRoot, ".claude-plugin", "plugin.json"),

},

],

},

});

expectNoDiagnostics(loaded.diagnostics);

expect(loaded.config.mcpServers.bundleProbe).toMatchObject({

command: "node",

});

});

it("merges inline bundle MCP servers and skips disabled bundles", async () => {

await withBundleHomeEnv(

tempHarness,

mergeBundlePathLists,

normalizeBundlePathList,

} from "./bundle-manifest.js";

import type { PluginManifestRegistry } from "./manifest-registry.js";

import type { PluginBundleFormat } from "./manifest-types.js";

export type BundleMcpServerConfig = Record<string, unknown>;

export function loadEnabledBundleMcpConfig(params: {

workspaceDir: string;

cfg?: OpenClawConfig;

manifestRegistry?: Pick<PluginManifestRegistry, "plugins">;

}): EnabledBundleMcpConfigResult {

return loadEnabledBundleConfig({

workspaceDir: params.workspaceDir,

cfg: params.cfg,

manifestRegistry: params.manifestRegistry,

createEmptyConfig: () => ({ mcpServers: {} }),

loadBundleConfig: loadBundleMcpConfig,

createDiagnostic: (pluginId, message) => ({ pluginId, message }),