@xopcai/xopc 0.0.303 → 0.0.307

package/dist/src/agent/external-tools/composio-provider.js

@@ -1,20 +1,26 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
-import { connectionBinding, connectionBindings, init_connection_wait_repository, publishConnectionWait, requireSessionConnection } from "../../storage/sqlite/connection-wait-repository.js";
-import { consumeConnectorApproval, createConnectorApproval, getConnectorApproval, getConnectorInstallation, listConnectorActionMetadata, listConnectorConnections, listConnectorInstallations, upsertConnectorActionMetadata, upsertConnectorInstallation } from "../../storage/sqlite/connector-repository.js";
+import { getSessionInputState, init_session_input_repository } from "../../storage/sqlite/session-input-repository.js";
+import { getConnectorAccount } from "../../storage/sqlite/connector-account-repository.js";
+import { consumeConnectorApproval, createConnectorApproval, getConnectorApproval, getConnectorConnection, getConnectorInstallation, listConnectorActionMetadata, listConnectorConnections, listConnectorInstallations, upsertConnectorActionMetadata, upsertConnectorInstallation } from "../../storage/sqlite/connector-repository.js";
+import { bindObjectiveAccount, connectionBinding, connectionBindings, connectorObjectiveScope, init_connection_wait_repository, publishConnectionWait, requireSessionConnection } from "../../storage/sqlite/connection-wait-repository.js";
 import "../../storage/sqlite/index.js";
 import { connectorArgumentsHash, connectorArgumentsPreview } from "../../connectors/approval.js";
+import { connectorIdentitySummary } from "../../connectors/connector-identity.js";
+import { canAccessConnectorAccount, currentAccountConnections } from "../../connectors/account-access.js";
 import { ComposioSessionsAdapter } from "../../connectors/composio-sessions.js";
 import { getComposioToolkitScope, getConfiguredComposioAuthConfigs, isComposioActionAllowedByCatalog, scopeForComposioAction } from "../../connectors/composio.js";
 import { getConnectorDefinition } from "../../connectors/catalog.js";
+import { listConnectorInstances } from "../../connectors/instances.js";
 import { isToolInputSchema } from "../../connectors/connection-capabilities.js";
 import { connectorPrincipalForSession } from "../../connectors/principal.js";
 import { ExternalToolSearchError } from "./search-error.js";
 import { externalToolRef, parseExternalToolRef } from "./refs.js";
 //#region src/agent/external-tools/composio-provider.ts
+init_session_input_repository();
 init_connection_wait_repository();
 init_logger();
-const CONNECTION_ARGUMENT = "xopcConnectionId";
+const CONNECTION_ARGUMENT = "xopcAccountId";
 const log = createLogger("ComposioToolProvider");
 function textResult(value) {
 	return {
@@ -62,7 +68,7 @@ function syncLocalOwnerInstallations(config) {
 			allowedAgentIds: existing?.allowedAgentIds ?? [],
 			maxScope: existing?.maxScope ?? getComposioToolkitScope(config, toolkit),
 			confirmationPolicy: existing?.confirmationPolicy ?? "writes",
-			selectedConnectionIds: existing?.selectedConnectionIds ?? [],
+			selectedAccountIds: existing?.selectedAccountIds ?? null,
 			createdAt: existing?.createdAt
 		});
 	}
@@ -98,6 +104,7 @@ function actionInputSchema(action) {
 	if (!isToolInputSchema(action.inputSchema)) throw new Error(`Exact input contract is unavailable for ${action.actionId}`);
 	const schema = action.inputSchema;
 	const properties = schema.properties && typeof schema.properties === "object" && !Array.isArray(schema.properties) ? schema.properties : {};
+	if (Object.hasOwn(properties, CONNECTION_ARGUMENT)) throw new Error("The provider contract conflicts with the reserved account selector.");
 	return {
 		...schema,
 		type: "object",
@@ -105,7 +112,7 @@ function actionInputSchema(action) {
 			...properties,
 			[CONNECTION_ARGUMENT]: {
 				type: "string",
-				description: "Optional local connection id when more than one account is connected."
+				description: "Stable local account ID. Required when this objective uses multiple accounts. Never guess an account."
 			}
 		}
 	};
@@ -190,13 +197,22 @@ var ComposioToolProvider = class {
 		const action = listConnectorActionMetadata(resolved.installation.connectorId).find((candidate) => candidate.actionId === resolved.actionId);
 		if (!action || !isToolInputSchema(action.inputSchema) || !isComposioActionAllowedByCatalog(action.actionId)) return void 0;
 		const summary = `Run ${action.actionId} in ${toolkit}.`;
+		const available = this.availableInstallations();
+		const accounts = currentAccountConnections(listConnectorConnections({
+			principalId: available.principalId,
+			connectorId: resolved.installation.connectorId
+		}).filter((connection) => canAccessConnectorAccount(connection, resolved.installation, available.agentId))).map((connection) => ({
+			accountId: connection.accountId,
+			label: getConnectorAccount(connection.accountId)?.label,
+			identity: connectorIdentitySummary(connection.identity)
+		}));
 		return {
 			toolRef,
 			source: this.source,
 			namespace: toolkit,
 			title: action.actionId,
 			summary,
-			description: summary,
+			description: `${summary} Available accounts: ${JSON.stringify(accounts)}. Use xopcAccountId to select one; never guess when the user's intent is ambiguous.`,
 			inputSchema: actionInputSchema(action)
 		};
 	}
@@ -220,19 +236,20 @@ var ComposioToolProvider = class {
 			const refreshed = await this.adapter.refreshConnection(expired);
 			fresh = fresh.map((item) => item.id === refreshed.id ? refreshed : item);
 		}
-		const connections = listConnectorConnections({
+		const connections = currentAccountConnections(listConnectorConnections({
 			principalId: available.principalId,
 			connectorId: resolved.installation.connectorId
-		}).filter((connection) => connection.status === "active" && fresh.some((item) => item.id === connection.id) && (!resolved.installation.selectedConnectionIds.length || resolved.installation.selectedConnectionIds.includes(connection.id)));
-		const requestedConnection = typeof executionArgs[CONNECTION_ARGUMENT] === "string" ? executionArgs[CONNECTION_ARGUMENT] : available.context ? connectionBinding(available.context.conversationId, resolved.installation.connectorId) : void 0;
+		}).filter((connection) => connection.status === "active" && fresh.some((item) => item.id === connection.id) && canAccessConnectorAccount(connection, resolved.installation, available.agentId)));
+		const boundConnection = available.context ? connectionBinding(available.context.conversationId, resolved.installation.connectorId) : void 0;
+		const requestedAccount = typeof executionArgs[CONNECTION_ARGUMENT] === "string" ? executionArgs[CONNECTION_ARGUMENT] : boundConnection ? getConnectorConnection(boundConnection)?.accountId : void 0;
 		const bindings = available.context ? connectionBindings(available.context.conversationId).filter((need) => need.connectorId === resolved.installation.connectorId) : [];
-		if (bindings.length > 1 && !requestedConnection) return textResult({
+		if (bindings.length > 1 && !requestedAccount) return textResult({
 			status: "account_selection_required",
 			accounts: bindings,
-			instruction: "Choose the account for this operation using xopcConnectionId."
+			instruction: "Choose the account for this operation using xopcAccountId."
 		});
-		if (bindings.length && requestedConnection && !bindings.some((need) => need.connectionId === requestedConnection)) return textResult("This account was not selected for the current objective.");
-		const connection = requestedConnection ? connections.find((candidate) => candidate.id === requestedConnection) : connections.length === 1 ? connections[0] : void 0;
+		if (bindings.length && requestedAccount && !bindings.some((need) => need.accountId === requestedAccount)) return textResult("This account was not selected for the current objective.");
+		const connection = requestedAccount ? connections.find((candidate) => candidate.accountId === requestedAccount) : connections.length === 1 ? connections[0] : void 0;
 		const requestConnection = () => {
 			if (!available.context) return textResult({ status: "connection_required" });
 			const result = requireSessionConnection({
@@ -243,7 +260,7 @@ var ComposioToolProvider = class {
 				needs: [{
 					key: `${resolved.installation.connectorId}:default`,
 					connectorId: resolved.installation.connectorId,
-					connectionId: requestedConnection,
+					accountId: requestedAccount,
 					label: getConnectorDefinition(resolved.installation.connectorId)?.displayName ?? toolkit,
 					capabilities: [action.actionId]
 				}]
@@ -252,13 +269,18 @@ var ComposioToolProvider = class {
 			return textResult(result);
 		};
 		if (!connection) return requestConnection();
+		if (available.context && connection.accountId) bindObjectiveAccount(available.context.conversationId, resolved.installation.connectorId, connection.accountId);
 		const actionArgs = { ...executionArgs };
 		delete actionArgs[CONNECTION_ARGUMENT];
-		const argsHash = connectorArgumentsHash(actionArgs);
+		const argsHash = connectorArgumentsHash({
+			args: actionArgs,
+			accountId: connection.accountId,
+			objective: available.context ? connectorObjectiveScope(available.context.conversationId) : void 0
+		});
 		let confirmed = false;
 		if (approvalId) {
 			const pending = getConnectorApproval(approvalId);
-			if (!pending || pending.principalId !== available.principalId || pending.connectorId !== resolved.installation.connectorId || pending.actionId !== action.actionId || pending.conversationId !== available.context?.conversationId) return textResult("The connector approval is invalid for this session or action.");
+			if (!pending || pending.principalId !== available.principalId || pending.connectorId !== resolved.installation.connectorId || pending.actionId !== action.actionId || pending.conversationId !== available.context?.conversationId || pending.agentId !== available.agentId || !pending.connectionId || getConnectorConnection(pending.connectionId)?.accountId !== connection.accountId) return textResult("The connector approval is invalid for this session or action.");
 			confirmed = Boolean(consumeConnectorApproval(approvalId, argsHash));
 			if (!confirmed) return textResult("The connector approval is not approved, has expired, or was already used.");
 		}
@@ -286,7 +308,22 @@ var ComposioToolProvider = class {
 			throw error;
 		}
 		if (result.decision === "confirmation_required") {
+			const wait = available.context && getSessionInputState(available.context.conversationId).activeInputId ? requireSessionConnection({
+				conversationId: available.context.conversationId,
+				principalId: available.principalId,
+				agentId: available.agentId ?? "main",
+				summary: `Confirm ${action.actionId}`,
+				needs: [{
+					key: `${resolved.installation.connectorId}:${connection.accountId}`,
+					connectorId: resolved.installation.connectorId,
+					accountId: connection.accountId,
+					connectionId: connection.id,
+					label: toolkit,
+					capabilities: [action.actionId]
+				}]
+			}) : void 0;
 			const approval = createConnectorApproval({
+				waitId: wait?.waitId,
 				principalId: available.principalId,
 				connectorId: resolved.installation.connectorId,
 				connectionId: connection?.id,
@@ -294,10 +331,22 @@ var ComposioToolProvider = class {
 				conversationId: available.context?.conversationId,
 				actionId: action.actionId,
 				scope: action.scope,
-				argumentsHash: argsHash,
-				argumentsPreview: connectorArgumentsPreview(actionArgs),
+				argumentsHash: connectorArgumentsHash({
+					args: actionArgs,
+					accountId: connection.accountId,
+					objective: available.context ? connectorObjectiveScope(available.context.conversationId) : void 0
+				}),
+				argumentsPreview: {
+					account: {
+						id: connection.accountId,
+						label: getConnectorAccount(connection.accountId)?.label,
+						identity: connectorIdentitySummary(connection.identity)
+					},
+					arguments: connectorArgumentsPreview(actionArgs)
+				},
 				expiresAt: new Date(Date.now() + 10 * 6e4).toISOString()
 			});
+			if (available.context && wait?.waitId) publishConnectionWait(available.context.conversationId);
 			return textResult({
 				status: "confirmation_required",
 				approvalId: approval.id,
@@ -305,17 +354,31 @@ var ComposioToolProvider = class {
 				scope: approval.scope,
 				argumentsPreview: approval.argumentsPreview,
 				expiresAt: approval.expiresAt,
+				account: {
+					id: connection.accountId,
+					label: getConnectorAccount(connection.accountId)?.label,
+					identity: connectorIdentitySummary(connection.identity)
+				},
 				instruction: "Ask the user to approve this exact action in xopc, then retry with the approvalId and unchanged arguments."
 			});
 		}
-		return textResult(result.decision === "allowed" ? result.result : result.reason);
+		return textResult(result.decision === "allowed" ? {
+			account: {
+				id: connection.accountId,
+				label: getConnectorAccount(connection.accountId)?.label,
+				identity: connectorIdentitySummary(connection.identity)
+			},
+			result: result.result
+		} : result.reason);
 	}
 	availableInstallations() {
 		const context = this.deps.getCurrentContext();
 		const principal = connectorPrincipalForSession(context?.conversationId);
 		if (principal.isLocalOwner) syncLocalOwnerInstallations(this.deps.getConfig());
 		const agentId = this.deps.agentId ?? principal.agentId;
-		const installations = listConnectorInstallations(principal.principalId).filter((installation) => installation.enabled && composioToolkitFromConnectorId(installation.connectorId) !== void 0 && (installation.allowedAgentIds.length === 0 || Boolean(agentId && installation.allowedAgentIds.includes(agentId))));
+		const config = this.deps.getConfig();
+		const disabled = new Set(config ? listConnectorInstances(config).filter((instance) => !instance.enabled).map((instance) => instance.connectorId) : []);
+		const installations = listConnectorInstallations(principal.principalId).filter((installation) => installation.enabled && !disabled.has(installation.connectorId) && composioToolkitFromConnectorId(installation.connectorId) !== void 0 && (installation.allowedAgentIds.length === 0 || Boolean(agentId && installation.allowedAgentIds.includes(agentId))));
 		return {
 			principalId: principal.principalId,
 			agentId,

package/dist/src/agent/external-tools/gateway-tools.js

@@ -1,11 +1,12 @@
+import { init_connector_repository, listConnectorConnections } from "../../storage/sqlite/connector-repository.js";
 import { connectionBindings, getActiveConnectionWait, init_connection_wait_repository, publishConnectionWait, requireSessionConnection, reviseCurrentConnectionObjective } from "../../storage/sqlite/connection-wait-repository.js";
-import { listConnectorConnections } from "../../storage/sqlite/connector-repository.js";
 import { connectorPrincipalForSession } from "../../connectors/principal.js";
 import { connectionCandidates, resolveConnectionCandidate } from "../../connectors/connection-candidates.js";
 import { ExternalToolService } from "./service.js";
 import { EXTERNAL_TOOL_SOURCES } from "./types.js";
 import { Type } from "@sinclair/typebox";
 //#region src/agent/external-tools/gateway-tools.ts
+init_connector_repository();
 init_connection_wait_repository();
 const EXTERNAL_TOOL_NAMES = {
 	search: "xopc_tool_search",

package/dist/src/agent/inbound/attachment-pipeline.d.ts

@@ -24,6 +24,8 @@ export declare function buildTranscriptUserMessage(opts: {
     modelRef: string;
     config: Config | undefined;
     agentManager: AgentInstanceGateway;
+    /** Keep these attachments in transcript metadata without exposing read_media hints to the LLM. */
+    suppressMediaPromptUris?: ReadonlySet<string>;
 }): Promise<TranscriptUserMessage>;
 /** Hydrate images from media store for the current LLM prompt. */
 export declare function hydrateUserTurnForLlm(opts: {

package/dist/src/agent/inbound/attachment-pipeline.js

@@ -58,8 +58,8 @@ async function readImageBase64FromRef(ref) {
 		mimeType: prepared.mimeType
 	};
 }
-function appendMediaAttachedLines(textParts, media) {
-	for (const ref of media) if (!isImageInboundAttachment(ref)) textParts.push([
+function appendMediaAttachedLines(textParts, media, suppressMediaPromptUris) {
+	for (const ref of media) if (!isImageInboundAttachment(ref) && !suppressMediaPromptUris?.has(ref.uri)) textParts.push([
 		`[media attached: ${ref.name} (${ref.mimeType}, ${ref.size} bytes)]`,
 		`xopc-media-uri:${ref.uri}`,
 		`xopc-media-path:${ref.path}`,
@@ -85,7 +85,7 @@ async function buildTranscriptUserMessage(opts) {
 	const textParts = [];
 	if (expandedText) textParts.push(expandedText);
 	const strategy = resolveImageHandlingStrategy(opts.modelRef);
-	appendMediaAttachedLines(textParts, prepared.filter((m) => !isImageInboundAttachment(m)));
+	appendMediaAttachedLines(textParts, prepared.filter((m) => !isImageInboundAttachment(m)), opts.suppressMediaPromptUris);
 	if (imageRefs.length > 0 && strategy !== "native") {
 		const images = await Promise.all(imageRefs.map((ref) => readImageBase64FromRef(ref)));
 		const agentId = opts.config ? extractProfileAgentId(opts.conversationId, opts.config) : void 0;

package/dist/src/agent/inbound/inbound-loop.js

@@ -95,6 +95,7 @@ var InboundLoop = class {
 				...sessionMetadata?.transcriptId ? { transcriptId: sessionMetadata.transcriptId } : {}
 			});
 			await this.cfg.sessionContextManager.runWith(sessionContext, async () => {
+				await this.cfg.agentManager.ensureMemoryReadyForSession?.(sessionContext.conversationId);
 				this.cfg.agentManager.getOrCreateAgent(sessionContext.conversationId);
 				this.cfg.setupSessionEventHandling(sessionContext.conversationId);
 				await this.cfg.sessionLifecycleManager.startSession(sessionContext);

package/dist/src/agent/inbound/turn-dispatcher.js

@@ -106,13 +106,14 @@ var TurnDispatcher = class {
 			sessionConfigStore: c.sessionConfigStore,
 			commandHandler: c.commandHandler,
 			prepareInboundAttachments: c.prepareInboundAttachments,
-			buildTranscriptUserMessage: async (text, prepared, sk) => buildDirectUserMessageContent({
+			buildTranscriptUserMessage: async (text, prepared, sk, options) => buildDirectUserMessageContent({
 				content: text,
 				attachments: prepared,
 				conversationId: sk,
 				config: c.requireConfig(),
 				agentManager: c.agentManager,
-				modelManager: c.modelManager
+				modelManager: c.modelManager,
+				suppressMediaPromptUris: options?.suppressMediaPromptUris
 			}),
 			recordTaskReviewStreamHint: (sk, o) => c.sessionState.recordTaskReviewStreamHint(sk, o),
 			enqueueProvisionalSessionTitle: (sk, userText) => {
@@ -128,7 +129,6 @@ var TurnDispatcher = class {
 			sourceContextResolver: c.sourceContextResolver,
 			maybeEmitWebchatTts: (sk, hadVoice) => maybeEmitWebchatTts({
 				config: c.getConfig(),
-				sessionStore: c.sessionStore,
 				getLastAssistantPlainText: (conversationId) => c.sessionState.getLastAssistantText(conversationId) ?? c.agentManager.getLastAssistantContent(conversationId) ?? "",
 				log: this.log
 			}, sk, hadVoice),

package/dist/src/agent/mcp/bundle-mcp-runtime.js

@@ -2,9 +2,9 @@ import { init_global_singleton, resolveGlobalSingleton } from "../../utils/globa
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { init_string_coerce, normalizeOptionalString } from "../../utils/string-coerce.js";
+import { resolveConnectorSecretReferences } from "../../connectors/secret-store.js";
 import { redactSensitiveUrlLikeString } from "../../utils/redact-sensitive-url.js";
 import { loadEmbeddedMcpConfig } from "./embedded-mcp.js";
-import { resolveConnectorSecretReferences } from "../../connectors/secret-store.js";
 import { isMcpConfigRecord } from "./mcp-config-shared.js";
 import { resolveMcpTransport } from "./mcp-transport.js";
 import { sanitizeServerName } from "./bundle-mcp-names.js";

package/dist/src/agent/mcp/mcp-stdio-transport.js

@@ -1,4 +1,4 @@
-import { killProcessTree } from "../../process/kill-tree.js";
+import { terminateProcess } from "../../process/kill-tree.js";
 import { spawn } from "node:child_process";
 import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import process from "node:process";
@@ -87,7 +87,10 @@ var XopcStdioClientTransport = class {
 			} catch {}
 			await Promise.race([closePromise, delay(CLOSE_TIMEOUT_MS)]);
 			if (processToClose.exitCode === null && processToClose.pid) {
-				killProcessTree(processToClose.pid);
+				await terminateProcess(processToClose, {
+					tree: true,
+					detached: process.platform !== "win32"
+				});
 				await Promise.race([closePromise, delay(CLOSE_TIMEOUT_MS)]);
 			}
 		}

package/dist/src/agent/mcp/oauth/mcp-oauth-manager.js

@@ -1,8 +1,8 @@
 import { init_global_singleton, resolveGlobalSingleton } from "../../../utils/global-singleton.js";
 import { createLogger } from "../../../utils/logger/index.js";
 import { init_logger } from "../../../utils/logger.js";
-import { redactSensitiveUrlLikeString } from "../../../utils/redact-sensitive-url.js";
 import { resolveConnectorSecretReferences } from "../../../connectors/secret-store.js";
+import { redactSensitiveUrlLikeString } from "../../../utils/redact-sensitive-url.js";
 import { resolveMcpTransportConfig } from "../mcp-transport-config.js";
 import { isMcpAuthorizationError } from "./mcp-oauth-errors.js";
 import { McpOAuthStore, canonicalMcpServerUrl } from "./mcp-oauth-store.js";

package/dist/src/agent/memory/compaction-promotion.js

@@ -1,4 +1,4 @@
-import { listKnowledgeItems, setKnowledgeStatus, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
+import { listKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
 import { resolveMemorySessionKind } from "./turn-provenance.js";
 import { createHash } from "node:crypto";
@@ -146,7 +146,12 @@ function promoteCompactionLedger(input) {
 		result.episodicRecordIds.push(episode.item.id);
 		if (!(active && input.audit.status === "passed" && sessionKind === "interactive" && originClass === "agent" && !classified.derivedFromRecalledContext && DURABLE_KINDS.has(item.kind))) {
 			const existingDurable = !active ? listKnowledgeItems({ limit: 2e3 }).find((entry) => entry.canonicalKey === `durable:${item.kind}:${stableId("fact", item.text)}`) : void 0;
-			if (existingDurable?.sourceConversationId === input.conversationId) setKnowledgeStatus(existingDurable.id, "archived");
+			if (existingDurable?.sourceConversationId === input.conversationId) transitionKnowledgeStatus({
+				id: existingDurable.id,
+				status: "archived",
+				actor: "runtime",
+				reason: "The source session no longer supports this durable memory."
+			});
 			result.rejectedRecordIds.push(episode.item.id);
 			continue;
 		}

package/dist/src/agent/memory/create-memory-manager.js

@@ -19,6 +19,7 @@ function resolveMemoryManagerOptions(config) {
 	const providerRouting = config.userContext.knowledgeMemory;
 	return {
 		searchStrategy: providerRouting.searchStrategy,
+		searchTimeoutMs: providerRouting.searchTimeoutMs,
 		writeStrategy: providerRouting.writeStrategy,
 		writePolicy: {
 			allowExternalWrites: providerRouting.allowExternalWrites,

package/dist/src/agent/memory/manager.d.ts

@@ -14,6 +14,7 @@ export interface MemoryManagerOptions extends MemoryRoutingOptions {
     loadProviders?: () => Promise<MemoryProvider[]>;
     writePolicy?: MemoryWritePolicy;
     memoryRuntime?: MemoryRuntime;
+    searchTimeoutMs?: number;
 }
 export interface MemoryWritePolicy {
     allowExternalWrites?: boolean;
@@ -27,7 +28,10 @@ export declare class MemoryManager {
     private readonly loadProviders?;
     private readonly writePolicy;
     private pluginProvidersLoaded;
+    private pluginProvidersPromise?;
+    private readonly sessionInitializations;
     private readonly memoryRuntime?;
+    private readonly searchTimeoutMs;
     private readonly sessionContexts;
     constructor(options?: MemoryManagerOptions);
     addProvider(provider: MemoryProvider): void;
@@ -48,6 +52,8 @@ export declare class MemoryManager {
     }>;
     handleToolCall(toolName: string, args: Record<string, unknown>): Promise<string>;
     search(request: MemorySearchRequest): Promise<MemorySearchResult[]>;
+    searchExternal(request: MemorySearchRequest): Promise<MemorySearchResult[]>;
+    private searchProviders;
     read(request: MemoryReadRequest): Promise<MemoryReadResult | null>;
     get(id: string): Promise<MemoryRecord | null>;
     list(request: MemoryListRequest): Promise<MemoryRecord[]>;

package/dist/src/agent/memory/manager.js

@@ -11,7 +11,10 @@ var MemoryManager = class {
 	loadProviders;
 	writePolicy;
 	pluginProvidersLoaded = false;
+	pluginProvidersPromise;
+	sessionInitializations = /* @__PURE__ */ new Map();
 	memoryRuntime;
+	searchTimeoutMs;
 	sessionContexts = /* @__PURE__ */ new Map();
 	constructor(options = {}) {
 		this.routing = {
@@ -21,6 +24,7 @@ var MemoryManager = class {
 		};
 		this.loadProviders = options.loadProviders;
 		this.memoryRuntime = options.memoryRuntime;
+		this.searchTimeoutMs = options.searchTimeoutMs ?? 2e3;
 		this.writePolicy = {
 			allowExternalWrites: options.writePolicy?.allowExternalWrites ?? false,
 			allowedProviderIds: options.writePolicy?.allowedProviderIds,
@@ -142,21 +146,29 @@ var MemoryManager = class {
 		return provider.handleToolCall(toolName, args);
 	}
 	async search(request) {
-		const providers = this.providersForSearch();
-		const results = [];
-		for (const p of providers) {
-			if (!p.capabilities.search || !p.search) continue;
+		return this.searchProviders(this.providersForSearch(), request);
+	}
+	async searchExternal(request) {
+		return this.searchProviders(this.providersForSearch().filter((provider) => !provider.capabilities.local), request);
+	}
+	async searchProviders(providers, request) {
+		const searchProvider = async (p) => {
+			if (!p.capabilities.search || !p.search) return [];
 			const started = Date.now();
 			try {
-				const providerResults = await p.search(request);
+				let timeout;
+				const providerResults = await Promise.race([p.search(request), new Promise((_resolve, reject) => {
+					timeout = setTimeout(() => reject(/* @__PURE__ */ new Error(`Memory search timed out after ${this.searchTimeoutMs}ms`)), this.searchTimeoutMs);
+				})]).finally(() => {
+					if (timeout) clearTimeout(timeout);
+				});
 				this.trace("search", p.id, request, {
 					resultCount: providerResults.length,
 					selectedRecordIds: providerResults.map((result) => result.record.id),
 					durationMs: Date.now() - started,
 					conversationId: request.scope?.conversationId
 				});
-				results.push(...providerResults);
-				if (providerResults.length > 0 && this.routing.searchStrategy !== "fanout") break;
+				return providerResults;
 			} catch (err) {
 				this.trace("search", p.id, request, {
 					error: err instanceof Error ? err.message : String(err),
@@ -167,7 +179,16 @@ var MemoryManager = class {
 					err,
 					id: p.id
 				}, "memory search failed");
+				return [];
 			}
+		};
+		const searchable = providers.filter((provider) => provider.capabilities.search && provider.search);
+		const results = [];
+		if (this.routing.searchStrategy === "fanout") results.push(...(await Promise.all(searchable.map(searchProvider))).flat());
+		else for (const provider of searchable) {
+			const providerResults = await searchProvider(provider);
+			results.push(...providerResults);
+			if (providerResults.length > 0) break;
 		}
 		const seen = /* @__PURE__ */ new Set();
 		return results.sort((a, b) => b.score - a.score).filter((result) => this.canReadRecord(result.record, request.scope)).filter((result) => !request.trustedOnly || (result.record.provenance?.originClass === "owner" || result.record.provenance?.originClass === "agent") && result.record.provenance?.derivedFromRecalledContext === false).filter((result) => {
@@ -245,12 +266,14 @@ var MemoryManager = class {
 		return this.writeWithStrategy("delete", request);
 	}
 	canReadRecord(record, scope) {
-		if (record.providerId !== "local") return true;
-		if (this.memoryRuntime && !this.memoryRuntime.canRead(memorySourceForRecord(record))) return false;
+		if (this.memoryRuntime) {
+			const { scope, source } = memoryAccessForRecord(record);
+			if (!this.memoryRuntime.canRead(scope, source)) return false;
+		}
 		if (record.scope.userId && scope?.userId && record.scope.userId !== scope.userId) return false;
-		if (record.scope.conversationId && record.scope.conversationId !== scope?.conversationId) return false;
-		if (record.scope.projectId && record.scope.projectId !== scope?.projectId) return false;
-		if (record.scope.workspaceId && record.scope.workspaceId !== scope?.workspaceId) return false;
+		if (record.scope.conversationId && scope?.conversationId && record.scope.conversationId !== scope.conversationId) return false;
+		if (record.scope.projectId && scope?.projectId && record.scope.projectId !== scope.projectId) return false;
+		if (record.scope.workspaceId && scope?.workspaceId && record.scope.workspaceId !== scope.workspaceId) return false;
 		return true;
 	}
 	recordSignal(signal) {
@@ -286,36 +309,48 @@ var MemoryManager = class {
 	}
 	async initializeAll(sessionId, options) {
 		if (options) this.sessionContexts.set(sessionId, { ...options });
-		await this.loadPluginProvidersOnce();
-		for (const p of this.providers) try {
-			await p.initialize(sessionId, options);
-		} catch (err) {
-			log.warn({
-				err,
-				id: p.id
-			}, "initialize failed");
-		}
+		const existing = this.sessionInitializations.get(sessionId);
+		if (existing) return existing;
+		const initialization = (async () => {
+			await this.loadPluginProvidersOnce();
+			for (const p of this.providers) try {
+				await p.initialize(sessionId, options);
+			} catch (err) {
+				log.warn({
+					err,
+					id: p.id,
+					sessionId
+				}, "Memory provider initialization failed");
+			}
+		})();
+		this.sessionInitializations.set(sessionId, initialization);
+		return initialization;
 	}
 	async loadPluginProvidersOnce() {
 		if (this.pluginProvidersLoaded || !this.loadProviders) return;
-		this.pluginProvidersLoaded = true;
-		try {
-			const providers = await this.loadProviders();
-			const existingIds = new Set(this.providers.map((p) => p.id));
-			for (const provider of providers) {
-				if (existingIds.has(provider.id)) {
-					log.warn({ id: provider.id }, "Skipped duplicate memory provider");
-					continue;
+		if (!this.pluginProvidersPromise) this.pluginProvidersPromise = (async () => {
+			try {
+				const providers = await this.loadProviders();
+				const existingIds = new Set(this.providers.map((p) => p.id));
+				for (const provider of providers) {
+					if (existingIds.has(provider.id)) {
+						log.warn({ id: provider.id }, "Skipped duplicate memory provider");
+						continue;
+					}
+					this.addProvider(provider);
+					existingIds.add(provider.id);
 				}
-				this.addProvider(provider);
-				existingIds.add(provider.id);
+			} catch (err) {
+				log.warn({ err }, "Memory provider plugin loading failed");
+			} finally {
+				this.pluginProvidersLoaded = true;
 			}
-		} catch (err) {
-			log.warn({ err }, "Memory provider plugin loading failed");
-		}
+		})();
+		await this.pluginProvidersPromise;
 	}
 	async shutdownAll() {
 		this.sessionContexts.clear();
+		this.sessionInitializations.clear();
 		for (const p of [...this.providers].reverse()) try {
 			await p.shutdown();
 		} catch (err) {
@@ -425,11 +460,11 @@ var MemoryManager = class {
 		}, "External memory provider operation");
 	}
 };
-function memorySourceForRecord(record) {
-	if (record.source.provider !== "builtin") return "connector";
-	if (record.scope.conversationId) return "session";
-	if (record.scope.projectId) return "project";
-	return "workspace";
+function memoryAccessForRecord(record) {
+	return {
+		scope: record.scope.conversationId ? "session" : record.scope.projectId ? "project" : record.scope.workspaceId ? "workspace" : "global",
+		source: record.source.provider === "builtin" ? "memory" : "connector"
+	};
 }
 function writeTargetForRecord(_request) {
 	return "knowledge";

package/dist/src/agent/memory/runtime.d.ts

@@ -1,5 +1,5 @@
 import type { UserContextConfig } from '../../user-context/config.js';
-export type MemorySource = 'session' | 'workspace' | 'project' | 'connector';
+import type { KnowledgeContentSource, KnowledgeReadPolicy, KnowledgeVisibilityScope } from '../../knowledge-memory/domain.js';
 export type MemoryWriteTarget = 'knowledge';
 export type MemoryWriteDecision = 'allow' | 'confirm' | 'deny';
 export interface MemoryCandidate {
@@ -14,8 +14,8 @@ export interface MemoryWriteCheckResult {
     reason: string;
 }
 export interface MemoryRuntime {
-    readableSources: MemorySource[];
-    canRead: (source: MemorySource) => boolean;
+    readPolicy: KnowledgeReadPolicy;
+    canRead: (scope: KnowledgeVisibilityScope, source: KnowledgeContentSource) => boolean;
     checkWrite: (candidate: MemoryCandidate) => MemoryWriteCheckResult;
 }
 export declare function buildMemoryRuntime(userContext: UserContextConfig): MemoryRuntime;

package/dist/src/agent/memory/runtime.js

@@ -5,11 +5,18 @@ function normalizeConfidence(value) {
 }
 function buildMemoryRuntime(userContext) {
 	const memory = userContext.knowledgeMemory;
-	const readableSources = !userContext.enabled || !memory.enabled ? [] : [...memory.sources];
-	const sourceSet = new Set(readableSources);
+	const readPolicy = !userContext.enabled || !memory.enabled ? {
+		scopes: [],
+		contentSources: []
+	} : {
+		scopes: memory.readScopes,
+		contentSources: memory.contentSources
+	};
+	const scopes = new Set(readPolicy.scopes);
+	const contentSources = new Set(readPolicy.contentSources);
 	return {
-		readableSources,
-		canRead: (source) => sourceSet.has(source),
+		readPolicy,
+		canRead: (scope, source) => scopes.has(scope) && contentSources.has(source),
 		checkWrite: (candidate) => {
 			if (!userContext.enabled || !memory.enabled) return {
 				decision: "deny",