@xopcai/xopc 0.0.171 → 0.0.172

package/dist/src/connectors/learning-coordinator.js

@@ -0,0 +1,214 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { claimNextConnectorLearningJob, enqueueConnectorLearningJob, listConnectorLearningJobs, recoverStaleConnectorLearningJobs, setConnectorLearningPaused, updateConnectorLearningJob } from "../storage/sqlite/connector-learning-repository.js";
+import { pruneBoundedKnowledgeSourceItems } from "../storage/sqlite/knowledge-repository.js";
+import { getConnectorInstallation, listConnectorConnections, upsertConnectorConnection } from "../storage/sqlite/connector-repository.js";
+import "../storage/sqlite/index.js";
+import { ComposioSessionsAdapter } from "./composio-sessions.js";
+import { getConnectorDefinition } from "./catalog.js";
+import { ConnectedUnderstandingPipeline } from "../knowledge/connected-understanding-pipeline.js";
+import "../knowledge/index.js";
+import { ingestComposioConnectedSource } from "./connected-source-ingestion.js";
+import { normalizeConnectorIdentity } from "./connector-identity.js";
+import { buildConnectorLearningArguments, getConnectorLearningPlan } from "./learning-recipes.js";
+//#region src/connectors/learning-coordinator.ts
+init_logger();
+const log = createLogger("ConnectorLearning");
+const CONNECTED_ACCOUNT_UNAVAILABLE = "connected_account_unavailable";
+const CONNECTED_SOURCE_SYNC_FAILED = "connected_source_sync_failed";
+function learningFailureCode(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return message.includes("ToolRouterV2_InvalidConnectedAccountIds") || message.includes("Could not find connected account(s)") || message.includes("missing its provider identity") ? CONNECTED_ACCOUNT_UNAVAILABLE : CONNECTED_SOURCE_SYNC_FAILED;
+}
+function learningEnabled(config) {
+	return config.userContext.enabled && config.userContext.understanding.enabled && config.userContext.memory.mode !== "off" && config.userContext.memory.sources.includes("connectedSources");
+}
+function startConnectorLearningCoordinator(options) {
+	const intervalMs = Math.max(2e3, Math.min(options.intervalMs ?? 1e4, 6e4));
+	let timer = null;
+	let running = false;
+	let stopped = false;
+	const composioAdapter = options.composioAdapter ?? new ComposioSessionsAdapter();
+	const publish = (job) => options.emit?.("connector.learning.updated", job);
+	function enqueueConnection(connectionId, request = {}) {
+		if (!learningEnabled(options.getConfig())) return null;
+		const connection = listConnectorConnections().find((item) => item.id === connectionId && item.status === "active");
+		if (!connection) return null;
+		const definition = getConnectorDefinition(connection.connectorId);
+		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") return null;
+		if (!getConnectorLearningPlan(definition.runtime.toolkit)) return null;
+		const sourceInstanceId = `composio:${connection.connectorId}:${connection.id}`;
+		const existing = listConnectorLearningJobs({
+			connectionId: connection.id,
+			limit: 1
+		});
+		const mode = request.mode ?? (existing.length === 0 ? "bootstrap" : "incremental");
+		const bucket = Math.floor(Date.now() / 6e4);
+		const job = enqueueConnectorLearningJob({
+			connectorId: connection.connectorId,
+			connectionId: connection.id,
+			sourceInstanceId,
+			agentId: options.resolveAgentId(),
+			mode,
+			idempotencyKey: request.idempotencyKey ?? (mode === "bootstrap" ? `bootstrap:${connection.id}:v1` : `incremental:${connection.id}:${request.reason ?? "manual"}:${bucket}`),
+			nextRunAt: request.nextRunAt
+		});
+		publish(job);
+		queueMicrotask(() => void runNow());
+		return job;
+	}
+	function enqueueToolkit(toolkit) {
+		const normalized = toolkit.trim().toLowerCase();
+		return listConnectorConnections().filter((connection) => connection.status === "active").filter((connection) => {
+			const definition = getConnectorDefinition(connection.connectorId);
+			return definition?.runtime.type === "composio" && definition.runtime.role === "toolkit" && definition.runtime.toolkit === normalized;
+		}).map((connection) => enqueueConnection(connection.id, { reason: "event" })).filter((job) => Boolean(job));
+	}
+	async function execute(job) {
+		publish(job);
+		const definition = getConnectorDefinition(job.connectorId);
+		if (definition?.runtime.type !== "composio" || definition.runtime.role !== "toolkit") throw new Error(`Connector learning is unavailable for ${job.connectorId}.`);
+		const plan = getConnectorLearningPlan(definition.runtime.toolkit);
+		if (!plan) throw new Error(`Connector learning has no plan for ${definition.runtime.toolkit}.`);
+		let connection = listConnectorConnections().find((candidate) => candidate.id === job.connectionId);
+		if (!connection) throw new Error("Connector account no longer exists.");
+		const installation = getConnectorInstallation(`${job.connectorId}-local-owner`);
+		if (!installation?.enabled) throw new Error("Connector installation is not enabled.");
+		const hasIdentity = Object.values(connection.identity).some((value) => typeof value === "string" && value.trim());
+		if (plan.identityProbe && (job.mode === "bootstrap" || !hasIdentity)) {
+			const execution = await composioAdapter.executeWithPolicy({
+				context: {
+					principalId: connection.principalId,
+					toolkits: [plan.toolkit]
+				},
+				installation: {
+					...installation,
+					maxScope: "read",
+					confirmationPolicy: "never"
+				},
+				connection,
+				agentId: job.agentId,
+				action: {
+					connectorId: job.connectorId,
+					actionId: plan.identityProbe.actionId,
+					toolkit: plan.toolkit,
+					scope: "read",
+					curated: true,
+					cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+				},
+				args: {},
+				confirmed: true
+			});
+			if (execution.decision !== "allowed") throw new Error(execution.reason);
+			connection = upsertConnectorConnection({
+				...connection,
+				identity: normalizeConnectorIdentity(plan.toolkit, execution.result)
+			});
+		}
+		let itemsSeen = 0;
+		let itemsIndexed = 0;
+		for (const stream of plan.streams) {
+			const synced = await ingestComposioConnectedSource({
+				config: options.getConfig(),
+				connectorId: job.connectorId,
+				connectionId: job.connectionId,
+				collectionScope: stream.scope,
+				streamKind: stream.kind,
+				actionId: stream.actionId,
+				arguments: stream.arguments,
+				buildArguments: (pull) => buildConnectorLearningArguments(plan, stream, pull, connection.identity),
+				agentId: job.agentId
+			});
+			itemsSeen += synced.itemsSeen;
+			itemsIndexed += synced.itemsIndexed;
+		}
+		if (listConnectorLearningJobs({
+			connectionId: job.connectionId,
+			limit: 100
+		}).find((candidate) => candidate.id === job.id)?.status === "paused") return;
+		publish(updateConnectorLearningJob(job.id, {
+			phase: "indexing",
+			itemsDiscovered: itemsSeen,
+			itemsIndexed
+		}));
+		publish(updateConnectorLearningJob(job.id, { phase: "deriving" }));
+		const understanding = await new ConnectedUnderstandingPipeline(options.getMemoryManager()).process(job.sourceInstanceId, job.connectorId, job.agentId);
+		publish(updateConnectorLearningJob(job.id, {
+			status: "completed",
+			phase: "completed",
+			candidatesCreated: understanding.created,
+			nextRunAt: null,
+			finished: true
+		}));
+		pruneBoundedKnowledgeSourceItems(job.sourceInstanceId, Date.now() - plan.bootstrapWindowDays * 24 * 60 * 6e4);
+		const nextRunAt = Date.now() + plan.intervalMinutes * 6e4;
+		enqueueConnection(job.connectionId, {
+			mode: "incremental",
+			reason: "schedule",
+			nextRunAt,
+			idempotencyKey: `scheduled:${job.connectionId}:${nextRunAt}`
+		});
+	}
+	async function runNow() {
+		if (running || stopped) return;
+		running = true;
+		try {
+			for (let count = 0; count < 10; count += 1) {
+				const job = claimNextConnectorLearningJob();
+				if (!job) break;
+				try {
+					await execute(job);
+				} catch (err) {
+					const errorMessage = err instanceof Error ? err.message : String(err);
+					const exhausted = job.attemptCount >= 5;
+					publish(updateConnectorLearningJob(job.id, {
+						status: exhausted ? "paused" : "failed",
+						error: learningFailureCode(err),
+						nextRunAt: exhausted ? null : Date.now() + Math.min(30 * 6e4, 3e4 * 2 ** Math.min(job.attemptCount, 6)),
+						finished: true
+					}));
+					log.warn({
+						err,
+						jobId: job.id,
+						connectorId: job.connectorId
+					}, `Connector learning failed: ${errorMessage}`);
+				}
+			}
+		} finally {
+			running = false;
+		}
+	}
+	recoverStaleConnectorLearningJobs(Date.now());
+	if (learningEnabled(options.getConfig())) {
+		for (const connection of listConnectorConnections().filter((item) => item.status === "active")) if (listConnectorLearningJobs({
+			connectionId: connection.id,
+			limit: 1
+		}).length === 0) enqueueConnection(connection.id, { reason: "schedule" });
+	}
+	timer = setTimeout(() => {
+		runNow();
+		timer = setInterval(() => void runNow(), intervalMs);
+		timer.unref?.();
+	}, Math.max(0, options.initialDelayMs ?? 2e3));
+	timer.unref?.();
+	return {
+		enqueueConnection,
+		enqueueToolkit,
+		setPaused(connectionId, paused) {
+			const changed = setConnectorLearningPaused(connectionId, paused);
+			if (!paused && changed > 0) queueMicrotask(() => void runNow());
+			return changed;
+		},
+		runNow,
+		stop() {
+			stopped = true;
+			if (timer) {
+				clearTimeout(timer);
+				clearInterval(timer);
+				timer = null;
+			}
+		}
+	};
+}
+//#endregion
+export { startConnectorLearningCoordinator };

package/dist/src/connectors/learning-recipes.d.ts

@@ -0,0 +1,22 @@
+export type ConnectorIdentityProbe = {
+    actionId: string;
+};
+export type ConnectorLearningStream = {
+    scope: string;
+    actionId: string;
+    arguments: Record<string, unknown>;
+    kind: 'activity' | 'inventory';
+};
+export type ConnectorLearningPlan = {
+    toolkit: string;
+    identityProbe?: ConnectorIdentityProbe;
+    streams: ConnectorLearningStream[];
+    bootstrapWindowDays: number;
+    intervalMinutes: number;
+};
+export declare function buildConnectorLearningArguments(plan: ConnectorLearningPlan, stream: ConnectorLearningStream, input: {
+    cursor?: string;
+    windowStart?: string;
+}, identity: Record<string, unknown>): Record<string, unknown>;
+export declare function getConnectorLearningPlan(toolkit: string): ConnectorLearningPlan | undefined;
+export declare function listConnectorLearningPlans(): ConnectorLearningPlan[];

package/dist/src/connectors/learning-recipes.js

@@ -0,0 +1,121 @@
+//#region src/connectors/learning-recipes.ts
+function buildConnectorLearningArguments(plan, stream, input, identity) {
+	if (plan.toolkit === "github" && stream.scope === "authored-work") {
+		const username = typeof identity.username === "string" ? identity.username.trim() : "";
+		if (!username) throw new Error("GitHub activity sync requires the authenticated username.");
+		return {
+			...stream.arguments,
+			q: `author:${username} sort:updated-desc`
+		};
+	}
+	if (!input.cursor) return { ...stream.arguments };
+	if (plan.toolkit === "gmail") {
+		const after = Math.floor(Date.parse(input.cursor) / 1e3);
+		return Number.isFinite(after) ? {
+			...stream.arguments,
+			query: `after:${after} -in:spam -in:trash`
+		} : { ...stream.arguments };
+	}
+	if (plan.toolkit === "googlecalendar") return {
+		...stream.arguments,
+		time_min: input.cursor
+	};
+	return { ...stream.arguments };
+}
+const PLANS = {
+	gmail: {
+		toolkit: "gmail",
+		identityProbe: { actionId: "GMAIL_GET_PROFILE" },
+		streams: [{
+			scope: "messages",
+			actionId: "GMAIL_FETCH_EMAILS",
+			kind: "activity",
+			arguments: {
+				max_results: 100,
+				query: "newer_than:30d -in:spam -in:trash"
+			}
+		}],
+		bootstrapWindowDays: 30,
+		intervalMinutes: 15
+	},
+	googlecalendar: {
+		toolkit: "googlecalendar",
+		streams: [{
+			scope: "events",
+			actionId: "GOOGLECALENDAR_LIST_EVENTS",
+			kind: "activity",
+			arguments: { max_results: 200 }
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 15
+	},
+	googledrive: {
+		toolkit: "googledrive",
+		streams: [{
+			scope: "files",
+			actionId: "GOOGLEDRIVE_SEARCH_FILES",
+			kind: "inventory",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 30
+	},
+	notion: {
+		toolkit: "notion",
+		streams: [{
+			scope: "pages",
+			actionId: "NOTION_SEARCH",
+			kind: "inventory",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 30
+	},
+	slack: {
+		toolkit: "slack",
+		streams: [{
+			scope: "channels",
+			actionId: "SLACK_LIST_CHANNELS",
+			kind: "inventory",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 30,
+		intervalMinutes: 15
+	},
+	github: {
+		toolkit: "github",
+		identityProbe: { actionId: "GITHUB_GET_THE_AUTHENTICATED_USER" },
+		streams: [{
+			scope: "repositories",
+			actionId: "GITHUB_LIST_REPOSITORIES_FOR_THE_AUTHENTICATED_USER",
+			kind: "inventory",
+			arguments: {}
+		}, {
+			scope: "authored-work",
+			actionId: "GITHUB_SEARCH_ISSUES_AND_PULL_REQUESTS",
+			kind: "activity",
+			arguments: { per_page: 100 }
+		}],
+		bootstrapWindowDays: 90,
+		intervalMinutes: 30
+	},
+	linear: {
+		toolkit: "linear",
+		streams: [{
+			scope: "issues",
+			actionId: "LINEAR_LIST_ISSUES",
+			kind: "activity",
+			arguments: {}
+		}],
+		bootstrapWindowDays: 60,
+		intervalMinutes: 15
+	}
+};
+function getConnectorLearningPlan(toolkit) {
+	return PLANS[toolkit.trim().toLowerCase()];
+}
+function listConnectorLearningPlans() {
+	return Object.values(PLANS);
+}
+//#endregion
+export { buildConnectorLearningArguments, getConnectorLearningPlan, listConnectorLearningPlans };

package/dist/src/connectors/runtime-status.d.ts

@@ -1,9 +1,2 @@
 import type { ConnectorConnection, ConnectorInstance } from './types.js';
-export type ComposioRuntimeProbe = {
-    connectorId: string;
-    checkedAt: string;
-    toolCount?: number;
-    error?: string;
-    connectionError?: boolean;
-};
-export declare function projectComposioRuntimeStatus(instances: ConnectorInstance[], connections: ConnectorConnection[], probes: ComposioRuntimeProbe[]): ConnectorInstance[];
+export declare function projectComposioConnectionStatus(instances: ConnectorInstance[], connections: ConnectorConnection[]): ConnectorInstance[];

package/dist/src/connectors/runtime-status.js

@@ -1,43 +1,18 @@
 //#region src/connectors/runtime-status.ts
-function projectComposioRuntimeStatus(instances, connections, probes) {
-	const probeByConnectorId = new Map(probes.map((probe) => [probe.connectorId, probe]));
+function projectComposioConnectionStatus(instances, connections) {
 	return instances.map((instance) => {
 		if (instance.materialized.type !== "composio" || instance.materialized.role !== "toolkit" || !instance.enabled) return instance;
 		const relevant = connections.filter((connection) => connection.provider === "composio" && connection.connectorId === instance.connectorId && connection.status !== "revoked");
 		const active = relevant.filter((connection) => connection.status === "active");
-		const probe = probeByConnectorId.get(instance.connectorId);
 		const lastConnectedAt = active.flatMap((connection) => connection.connectedAt ? [connection.connectedAt] : []).sort().at(-1) ?? instance.lastConnectedAt;
-		if (active.length > 0 && probe && !probe.error && (probe.toolCount ?? 0) > 0) return {
+		if (active.length > 0) return {
 			...instance,
 			status: "connected",
 			connectionStatus: "connected",
 			authStatus: "connected",
 			lastConnectedAt,
-			lastError: void 0,
-			usage: {
-				...instance.usage,
-				lastHealthCheckAt: probe.checkedAt,
-				lastHealthStatus: "ok",
-				lastToolCount: probe.toolCount
-			}
+			lastError: void 0
 		};
-		if (active.length > 0 && probe) {
-			const error = probe.error ?? "The connection did not expose any usable tools.";
-			return {
-				...instance,
-				status: "degraded",
-				connectionStatus: probe.connectionError ? "error" : "connected",
-				authStatus: "connected",
-				lastConnectedAt,
-				lastError: error,
-				usage: {
-					...instance.usage,
-					lastHealthCheckAt: probe.checkedAt,
-					lastHealthStatus: probe.connectionError ? "network_failed" : "tools_list_failed",
-					lastToolCount: probe.toolCount ?? 0
-				}
-			};
-		}
 		if (relevant.some((connection) => connection.status === "pending")) return {
 			...instance,
 			status: "connecting",
@@ -65,4 +40,4 @@ function projectComposioRuntimeStatus(instances, connections, probes) {
 	});
 }
 //#endregion
-export { projectComposioRuntimeStatus };
+export { projectComposioConnectionStatus };

package/dist/src/gateway/hono/routes/connectors.js

@@ -1,3 +1,4 @@
+import { listConnectorLearningJobs } from "../../../storage/sqlite/connector-learning-repository.js";
 import { decideConnectorApproval, getConnectorApproval, listConnectorApprovals, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
 import "../../../storage/sqlite/index.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
@@ -15,11 +16,10 @@ import { composioLogoResponse } from "../../../connectors/composio-logo.js";
 import { appendComposioTriggerEvent, listComposioTriggerEvents } from "../../../connectors/composio-triggers.js";
 import { buildConnectedPeopleGraph } from "../../../knowledge/people-graph.js";
 import "../../../knowledge/index.js";
-import { syncComposioResultToMemory, syncLocalFolderToMemory } from "../../../connectors/connector-memory-sync.js";
+import { ingestLocalFolderSource } from "../../../connectors/connected-source-ingestion.js";
 import { previewConnectorDefinition, testConnectorInstance } from "../../../connectors/health.js";
 import { setConnectorEnabled } from "../../../connectors/lifecycle.js";
-import { getComposioMemorySyncProfile, updateComposioMemorySyncProfile } from "../../../connectors/memory-sync-profile.js";
-import { projectComposioRuntimeStatus } from "../../../connectors/runtime-status.js";
+import { projectComposioConnectionStatus } from "../../../connectors/runtime-status.js";
 //#region src/gateway/hono/routes/connectors.ts
 init_agent_scope();
 function errorMessage(error) {
@@ -39,45 +39,13 @@ function registerConnectorRoutes(authenticated, deps) {
 			}
 		});
 	});
-	authenticated.get("/api/connectors/installed", async (c) => {
+	authenticated.get("/api/connectors/installed", (c) => {
 		const config = service.currentConfig;
 		const instances = listConnectorInstances(config);
-		const composioInstances = instances.filter((instance) => instance.materialized.type === "composio" && instance.materialized.role === "toolkit");
-		if (composioInstances.length === 0) return c.json({
-			ok: true,
-			payload: { instances }
-		});
-		const checkedAt = (/* @__PURE__ */ new Date()).toISOString();
-		let connectionError;
-		try {
-			await listComposioConnections();
-		} catch (error) {
-			connectionError = errorMessage(error);
-		}
-		const probes = await Promise.all([...new Map(composioInstances.map((instance) => [instance.connectorId, instance])).values()].map(async (instance) => {
-			try {
-				const tools = await listComposioTools(instance.materialized.type === "composio" ? instance.materialized.toolkit : "", config);
-				return {
-					connectorId: instance.connectorId,
-					checkedAt,
-					toolCount: tools.length,
-					...connectionError ? {
-						error: connectionError,
-						connectionError: true
-					} : {}
-				};
-			} catch (error) {
-				return {
-					connectorId: instance.connectorId,
-					checkedAt,
-					error: errorMessage(error)
-				};
-			}
-		}));
 		const connections = listConnectorConnections({ principalId: "local-owner" });
 		return c.json({
 			ok: true,
-			payload: { instances: projectComposioRuntimeStatus(instances, connections, probes) }
+			payload: { instances: projectComposioConnectionStatus(instances, connections) }
 		});
 	});
 	authenticated.post("/api/connectors/setup/request-secret", strictRateLimitMiddleware, async (c) => {
@@ -118,6 +86,54 @@ function registerConnectorRoutes(authenticated, deps) {
 			}, 400);
 		}
 	});
+	authenticated.get("/api/connectors/learning", (c) => {
+		return c.json({
+			ok: true,
+			payload: { jobs: listConnectorLearningJobs({ limit: 100 }) }
+		});
+	});
+	authenticated.post("/api/connectors/composio/connections/:id/learning", strictRateLimitMiddleware, async (c) => {
+		try {
+			await listComposioConnections();
+			const config = service.currentConfig;
+			if (!config.userContext.memory.sources.includes("connectedSources")) {
+				config.userContext.memory.sources = [...config.userContext.memory.sources, "connectedSources"];
+				const saved = await service.saveConfig(config);
+				if (!saved.saved) return c.json({
+					ok: false,
+					error: saved.error
+				}, 500);
+			}
+			const job = service.requestConnectorLearning(c.req.param("id"), { reason: "manual" });
+			if (!job) return c.json({
+				ok: false,
+				error: "The connection is not active or does not support learning."
+			}, 409);
+			return c.json({
+				ok: true,
+				payload: { job }
+			}, 202);
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: errorMessage(error)
+			}, 400);
+		}
+	});
+	authenticated.post("/api/connectors/composio/connections/:id/learning/pause", strictRateLimitMiddleware, (c) => {
+		const changed = service.setConnectorLearningPaused(c.req.param("id"), true);
+		return c.json({
+			ok: true,
+			payload: { changed }
+		});
+	});
+	authenticated.post("/api/connectors/composio/connections/:id/learning/resume", strictRateLimitMiddleware, (c) => {
+		const changed = service.setConnectorLearningPaused(c.req.param("id"), false);
+		return c.json({
+			ok: true,
+			payload: { changed }
+		});
+	});
 	authenticated.patch("/api/connectors/composio/connections/:id", strictRateLimitMiddleware, async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
@@ -153,7 +169,9 @@ function registerConnectorRoutes(authenticated, deps) {
 	});
 	authenticated.delete("/api/connectors/composio/connections/:id", strictRateLimitMiddleware, async (c) => {
 		try {
-			await revokeComposioConnection(c.req.param("id"));
+			const connectionId = c.req.param("id");
+			await revokeComposioConnection(connectionId);
+			service.setConnectorLearningPaused(connectionId, true);
 			return c.json({
 				ok: true,
 				payload: { revoked: true }
@@ -275,7 +293,7 @@ function registerConnectorRoutes(authenticated, deps) {
 		const body = await c.req.json().catch(() => ({}));
 		try {
 			const event = await appendComposioTriggerEvent(service.currentConfig, body);
-			service.requestConnectorMemorySync(event.toolkit);
+			if (event.toolkit) service.requestConnectorLearningForToolkit(event.toolkit);
 			return c.json({
 				ok: true,
 				payload: { event }
@@ -313,43 +331,6 @@ function registerConnectorRoutes(authenticated, deps) {
 			})
 		});
 	});
-	authenticated.get("/api/connectors/:id/memory-sync-profile", (c) => {
-		const profile = getComposioMemorySyncProfile(service.currentConfig, c.req.param("id"));
-		return c.json({
-			ok: true,
-			payload: { profile: profile ?? null }
-		});
-	});
-	authenticated.patch("/api/connectors/:id/memory-sync-profile", strictRateLimitMiddleware, async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
-		try {
-			const config = service.currentConfig;
-			const profile = updateComposioMemorySyncProfile(config, c.req.param("id"), {
-				enabled: row.enabled === true,
-				actionId: typeof row.actionId === "string" ? row.actionId : "",
-				arguments: row.arguments && typeof row.arguments === "object" && !Array.isArray(row.arguments) ? row.arguments : {},
-				agentId: typeof row.agentId === "string" ? row.agentId : "",
-				connectionId: typeof row.connectionId === "string" ? row.connectionId : void 0,
-				intervalMinutes: Number(row.intervalMinutes),
-				triggerSync: row.triggerSync !== false
-			});
-			const saved = await service.saveConfig(config);
-			if (!saved.saved) return c.json({
-				ok: false,
-				error: saved.error
-			}, 500);
-			return c.json({
-				ok: true,
-				payload: { profile }
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: errorMessage(error)
-			}, 400);
-		}
-	});
 	authenticated.get("/api/connectors/:id", (c) => {
 		const connectorId = c.req.param("id");
 		const connector = getConnectorDefinition(connectorId);
@@ -395,48 +376,6 @@ function registerConnectorRoutes(authenticated, deps) {
 			payload: { health }
 		});
 	});
-	authenticated.post("/api/connectors/:id/memory-sync", strictRateLimitMiddleware, async (c) => {
-		const body = await c.req.json().catch(() => ({}));
-		const row = body && typeof body === "object" && !Array.isArray(body) ? body : {};
-		const actionId = typeof row.actionId === "string" ? row.actionId.trim() : "";
-		const config = service.currentConfig;
-		const agentId = typeof row.agentId === "string" && row.agentId.trim() ? row.agentId.trim() : resolveDefaultAgentId(config);
-		try {
-			const connectorId = c.req.param("id");
-			if (getConnectorDefinition(connectorId)?.runtime.type === "memorySource") {
-				const result = await syncLocalFolderToMemory({
-					config,
-					connectorId,
-					agentId
-				});
-				return c.json({
-					ok: true,
-					payload: result
-				});
-			}
-			if (!actionId) return c.json({
-				ok: false,
-				error: "actionId is required for Composio memory sync."
-			}, 400);
-			const result = await syncComposioResultToMemory({
-				config,
-				connectorId,
-				actionId,
-				agentId,
-				connectionId: typeof row.connectionId === "string" ? row.connectionId : void 0,
-				arguments: row.arguments && typeof row.arguments === "object" && !Array.isArray(row.arguments) ? row.arguments : {}
-			});
-			return c.json({
-				ok: true,
-				payload: result
-			});
-		} catch (error) {
-			return c.json({
-				ok: false,
-				error: errorMessage(error)
-			}, 400);
-		}
-	});
 	authenticated.get("/api/connectors/composio/:toolkit/policy", (c) => {
 		const config = service.currentConfig;
 		try {
@@ -632,6 +571,25 @@ function registerConnectorRoutes(authenticated, deps) {
 			}, 500);
 		}
 	});
+	authenticated.post("/api/connectors/:id/source-sync", strictRateLimitMiddleware, async (c) => {
+		const config = service.currentConfig;
+		try {
+			const result = await ingestLocalFolderSource({
+				config,
+				connectorId: c.req.param("id"),
+				agentId: resolveDefaultAgentId(config)
+			});
+			return c.json({
+				ok: true,
+				payload: result
+			});
+		} catch (error) {
+			return c.json({
+				ok: false,
+				error: errorMessage(error)
+			}, 400);
+		}
+	});
 	authenticated.post("/api/connectors/:id/config", strictRateLimitMiddleware, async (c) => {
 		const instanceId = c.req.param("id");
 		const body = await c.req.json().catch(() => ({}));