@sparkelf/dsh-dataops-managed 0.3.2 → 0.3.4

package/lib/index.js

@@ -1,6 +1,374 @@
 import { credentialRef } from "@deepseek-ai/dsh-credentials";
 import * as McpClient from "@sparkelf/dsh-plugin-mcp-credentials";
 import z from "@deepseek-ai/schemastery";
+//#region src/model-settings.ts
+/** Profile entry id whose Config holds the model providers. */
+const MODEL_SETTINGS_NAMESPACE = "llm-pi-ai";
+/** Field within that entry's Config holding provider profiles keyed by provider id. */
+const PROVIDERS_FIELD = "providers";
+/** Model ids inside a provider profile, as the plugin stores them. */
+const MODELS_FIELD = "models";
+/** Read a model's stable identity inside a provider profile. */
+function modelIdOf(entry) {
+	const id = entry.id;
+	return typeof id === "string" && id.trim() !== "" ? id : null;
+}
+/** Narrow an unknown value to a plain object. */
+function asRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+/** Read provider profiles out of a settings value. */
+function providersOf(value) {
+	const root = asRecord$1(value);
+	const providers = root === null ? null : asRecord$1(root[PROVIDERS_FIELD]);
+	if (providers === null) return {};
+	const result = {};
+	for (const [providerId, profile] of Object.entries(providers)) {
+		const narrowed = asRecord$1(profile);
+		if (narrowed !== null) result[providerId] = narrowed;
+	}
+	return result;
+}
+/**
+* Read the models this workspace currently holds.
+*
+* A missing section is an empty result rather than an error: a fresh workspace has never
+* opened the models page, and that is the normal state for the first user to arrive.
+* @param ctx - DSH Host context carrying the settings service.
+* @returns Provider profiles and the revision the read observed.
+*/
+function readModels(ctx) {
+	const descriptor = ctx.settings.describe().find((entry) => entry.ns === MODEL_SETTINGS_NAMESPACE);
+	if (descriptor === void 0) return {
+		providers: {},
+		revision: void 0
+	};
+	return {
+		providers: providersOf(descriptor.value),
+		revision: descriptor.revision
+	};
+}
+/**
+* Collect every model id a workspace holds, grouped by provider.
+* @param providers - Provider profiles to walk.
+* @returns Model ids offered by each provider.
+*/
+function modelIdsByProvider(providers) {
+	const result = {};
+	for (const [providerId, profile] of Object.entries(providers)) {
+		const models = profile[MODELS_FIELD];
+		if (!Array.isArray(models)) continue;
+		result[providerId] = models.map((entry) => asRecord$1(entry)).filter((entry) => entry !== null).map((entry) => modelIdOf(entry)).filter((id) => id !== null);
+	}
+	return result;
+}
+/**
+* Narrow published providers to the models their publisher offers.
+*
+* The publisher decides which of its models other users may use; a model it kept private is
+* dropped here, so it is never written into a reader's settings at all.
+* @param providers - Published provider profiles.
+* @param sharedModelIds - Model ids the publisher offers.
+* @returns Providers holding only the offered models.
+*/
+function selectSharedModels(providers, sharedModelIds) {
+	const offered = new Set(sharedModelIds);
+	if (offered.size === 0) return {};
+	const result = {};
+	for (const [providerId, profile] of Object.entries(providers)) {
+		const models = profile[MODELS_FIELD];
+		if (!Array.isArray(models)) continue;
+		const kept = models.filter((entry) => {
+			const narrowed = asRecord$1(entry);
+			const id = narrowed === null ? null : modelIdOf(narrowed);
+			return id !== null && offered.has(id);
+		});
+		if (kept.length === 0) continue;
+		result[providerId] = {
+			...profile,
+			[MODELS_FIELD]: kept
+		};
+	}
+	return result;
+}
+/**
+* Merge adopted provider profiles into the ones a workspace already holds.
+*
+* A provider the user already has keeps its own models and gains the adopted ones that are
+* missing, so adopting never removes a model the user configured. The user's own entry for a
+* model wins on conflict: that is what keeps a local edit from being overwritten.
+* @param local - Providers the workspace holds now.
+* @param adopted - Providers the publisher offers.
+* @returns Providers to write, and whether anything changed.
+*/
+function mergeProviders(local, adopted) {
+	const result = { ...local };
+	let changed = false;
+	for (const [providerId, adoptedProfile] of Object.entries(adopted)) {
+		const adoptedModels = Array.isArray(adoptedProfile[MODELS_FIELD]) ? adoptedProfile[MODELS_FIELD] : [];
+		const localProfile = result[providerId];
+		if (localProfile === void 0) {
+			result[providerId] = adoptedProfile;
+			changed = changed || adoptedModels.length > 0;
+			continue;
+		}
+		const localModels = Array.isArray(localProfile[MODELS_FIELD]) ? localProfile[MODELS_FIELD] : [];
+		const localIds = new Set(localModels.map((entry) => asRecord$1(entry)).filter((entry) => entry !== null).map((entry) => modelIdOf(entry)).filter((id) => id !== null));
+		const missing = adoptedModels.filter((entry) => {
+			const narrowed = asRecord$1(entry);
+			const id = narrowed === null ? null : modelIdOf(narrowed);
+			return id !== null && !localIds.has(id);
+		});
+		if (missing.length === 0) continue;
+		result[providerId] = {
+			...localProfile,
+			[MODELS_FIELD]: [...localModels, ...missing]
+		};
+		changed = true;
+	}
+	return {
+		providers: result,
+		changed
+	};
+}
+/**
+* Write provider profiles into this workspace's settings.
+*
+* The write presents the revision the read observed. A settings service that has moved on
+* refuses it with its own conflict error, which the caller surfaces rather than retrying:
+* silently overwriting a concurrent edit is exactly what this feature must not do.
+* @param ctx - DSH Host context carrying the settings service.
+* @param providers - Providers to store.
+* @param revision - Revision from the read this write is based on.
+*/
+async function writeModels(ctx, providers, revision) {
+	await ctx.settings.update(MODEL_SETTINGS_NAMESPACE, { [PROVIDERS_FIELD]: providers }, revision);
+}
+//#endregion
+//#region src/model-sync.ts
+/** Narrow an unknown value to a plain object. */
+function asRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+/**
+* Own the model-sync state one workspace keeps.
+*
+* The state lives in this workspace rather than in DataOps, because whether a user has written
+* their own models is a fact about this workspace. Keeping it here is also what makes the
+* promise hold across restarts: a user who chose their own models is not adopted again.
+*/
+var ModelSync = class {
+	ctx;
+	config;
+	store;
+	constructor(ctx, config, store) {
+		this.ctx = ctx;
+		this.config = config;
+		this.store = store;
+	}
+	/**
+	* Read the DataOps JWT this workspace is currently authorized with.
+	* @returns The token, or undefined when the workspace has no session yet.
+	*/
+	async token() {
+		return (await this.ctx.credentials.resolve(credentialRef(this.config.credentialRef)))?.value;
+	}
+	/** The DataOps API origin this workspace reports to. */
+	apiBase() {
+		return new URL(this.config.baseUrl).origin;
+	}
+	/**
+	* Fetch the publication this workspace may adopt.
+	* @returns The published snapshot, or undefined when the workspace is not authorized.
+	*/
+	async fetchPublished() {
+		const token = await this.token();
+		if (token === void 0) return void 0;
+		const response = await fetch(new URL("/api/ai/shared-models/published", this.apiBase()), {
+			method: "POST",
+			headers: { authorization: `Bearer ${token}` }
+		});
+		if (response.status === 401) return void 0;
+		if (!response.ok) throw new Error(`Shared model read failed with HTTP ${String(response.status)}`);
+		const body = asRecord(await response.json());
+		if (body === null) return void 0;
+		const payload = asRecord(body.payload);
+		const providers = payload === null ? null : asRecord(payload.providers);
+		return {
+			sharingEnabled: body.sharingEnabled === true,
+			payload: {
+				providers: providers === null ? {} : providers,
+				sharedModelIds: Array.isArray(payload?.sharedModelIds) ? payload.sharedModelIds.filter((id) => typeof id === "string") : []
+			},
+			updatedAt: typeof body.updatedAt === "string" ? body.updatedAt : null
+		};
+	}
+	/**
+	* The models this workspace offers to others.
+	*
+	* Every model is offered unless the administrator marked it private, which is what makes a
+	* newly added model shared without an extra step.
+	* @param providers - Providers this workspace holds.
+	* @param privateModelIds - Model ids kept private.
+	* @returns Model ids to offer.
+	*/
+	offeredModelIds(providers, privateModelIds) {
+		const held = Object.values(modelIdsByProvider(providers)).flat();
+		const privateIds = new Set(privateModelIds);
+		return held.filter((id) => !privateIds.has(id));
+	}
+	/**
+	* Report this workspace's models to DataOps as a publication.
+	*
+	* Called when an administrator turns sharing on, or edits their models while it is on. The
+	* workspace stays the owner of the configuration; DataOps stores only this copy.
+	* @param sharingEnabled - Whether sharing is on.
+	*/
+	async publish(sharingEnabled) {
+		const token = await this.token();
+		if (token === void 0) throw new Error("This workspace has no DataOps session to publish with");
+		const state = this.store.read();
+		const current = readModels(this.ctx);
+		const response = await fetch(new URL("/api/ai/shared-models/publication", this.apiBase()), {
+			method: "PUT",
+			headers: {
+				authorization: `Bearer ${token}`,
+				"content-type": "application/json"
+			},
+			body: JSON.stringify({
+				sharingEnabled,
+				providers: current.providers,
+				sharedModelIds: this.offeredModelIds(current.providers, state.privateModelIds)
+			})
+		});
+		if (!response.ok) throw new Error(`Shared model publish failed with HTTP ${String(response.status)}`);
+	}
+	/**
+	* Read the current user's own publication state and whether they may change it.
+	*
+	* The permission rule lives in DataOps; the browser only displays what this reports, so
+	* nothing in the page decides who is an administrator.
+	* @returns The state, or null when the workspace is not authorized.
+	*/
+	async readOwnState() {
+		const token = await this.token();
+		if (token === void 0) return null;
+		const response = await fetch(new URL("/api/ai/shared-models/publication", this.apiBase()), { headers: { authorization: `Bearer ${token}` } });
+		if (response.status === 401) return null;
+		if (!response.ok) throw new Error(`Shared model status read failed with HTTP ${String(response.status)}`);
+		const body = asRecord(await response.json());
+		return {
+			sharingEnabled: body?.sharingEnabled === true,
+			canPublish: body?.canPublish === true
+		};
+	}
+	/**
+	* Record which models the administrator keeps private.
+	* @param privateModelIds - Model ids not offered to other users.
+	* @param sharingEnabled - Whether sharing is on, so the change reaches readers now.
+	*/
+	async setPrivateModels(privateModelIds, sharingEnabled) {
+		const state = this.store.read();
+		await this.store.write({
+			...state,
+			privateModelIds: [...new Set(privateModelIds)]
+		});
+		if (sharingEnabled) await this.publish(true);
+	}
+	/**
+	* Adopt the published models into this workspace.
+	*
+	* Does nothing when the user here writes their own models, which is what keeps a local edit
+	* from being replaced by the publisher's version. Otherwise it merges: models the workspace
+	* lacks are added, and a model it already holds is left exactly as it is.
+	* @returns Adopted provider profiles, or null when nothing was adopted.
+	*/
+	async adopt() {
+		const state = this.store.read();
+		if (state.detached) return null;
+		const published = await this.fetchPublished();
+		if (published === void 0 || !published.sharingEnabled) return null;
+		const offered = selectSharedModels(published.payload.providers, published.payload.sharedModelIds);
+		if (Object.keys(offered).length === 0) return null;
+		const offeredIds = [...new Set(Object.values(modelIdsByProvider(offered)).flat())];
+		const current = readModels(this.ctx);
+		if (this.editedSinceAdoption(current.providers, state.adoptedModelIds)) {
+			await this.store.write({
+				...state,
+				detached: true
+			});
+			return null;
+		}
+		const merged = mergeProviders(current.providers, offered);
+		if (merged.changed) await writeModels(this.ctx, merged.providers, current.revision);
+		await this.store.write({
+			...state,
+			adoptedModelIds: offeredIds
+		});
+		return offered;
+	}
+	/**
+	* Whether this workspace holds models adoption did not put there.
+	*
+	* A model the workspace has now and adoption did not write is the user's own, so adopting
+	* again would discard their work. An empty record means adoption never ran here, and the
+	* first pass must not read the workspace's existing models as an edit.
+	* @param current - Providers the workspace holds now.
+	* @param adoptedModelIds - Model ids adoption last wrote.
+	* @returns True when the workspace holds something adoption did not write.
+	*/
+	editedSinceAdoption(current, adoptedModelIds) {
+		if (adoptedModelIds.length === 0) return false;
+		const adopted = new Set(adoptedModelIds);
+		return Object.values(modelIdsByProvider(current)).flat().some((id) => !adopted.has(id));
+	}
+	/**
+	* Stop following the publisher and keep what this workspace holds now.
+	*
+	* A user who chose their own models must not be pulled back, so this choice is stored and
+	* survives the next start.
+	*/
+	async detach() {
+		await this.store.write({
+			...this.store.read(),
+			detached: true
+		});
+	}
+	/**
+	* Follow the publisher again, adopting its models on the next pass.
+	*/
+	async resumeFollowing() {
+		await this.store.write({
+			...this.store.read(),
+			detached: false
+		});
+	}
+	/**
+	* Describe the current state for the settings UI.
+	* @returns The sync state, whether the viewer may publish, and their own models.
+	*/
+	async status() {
+		const state = this.store.read();
+		const own = await this.readOwnState();
+		const published = await this.fetchPublished();
+		const offered = published === void 0 || !published.sharingEnabled ? {} : selectSharedModels(published.payload.providers, published.payload.sharedModelIds);
+		const held = [...new Set(Object.values(modelIdsByProvider(readModels(this.ctx).providers)).flat())];
+		const privateIds = new Set(state.privateModelIds);
+		return {
+			followState: state.detached ? "detached" : "following",
+			publisherSharing: published?.sharingEnabled === true,
+			adoptedCount: Object.values(modelIdsByProvider(offered)).flat().length,
+			privateModelIds: state.privateModelIds,
+			publishedAt: published?.updatedAt ?? null,
+			canPublish: own?.canPublish === true,
+			models: held.map((id) => ({
+				id,
+				shared: !privateIds.has(id)
+			}))
+		};
+	}
+};
+//#endregion
 //#region src/index.ts
 /** Cordis plugin name for the DataOps-managed integration. */
 const name = "dataops-managed";
@@ -8,15 +376,35 @@ const name = "dataops-managed";
 const inject = [
 	"credentials",
 	"webServer",
-	"tools"
+	"tools",
+	"settings"
 ];
 const MANAGED_AUTH_PATH = "/integrations/dataops/managed-auth";
+/** This plugin's profile entry id, which owns its Config and sync state. */
+const MANAGED_PLUGIN_ID = "dataops-managed";
+/** Same-origin route the workspace settings pages use to read and change model sharing. */
+const MODEL_SYNC_PATH = "/integrations/dataops/model-sync";
+/** The live sync instance, so the settings routes can act on it after activation. */
+let modelSyncRef;
+/** The live model-sync instance, once this plugin activated. */
+function currentModelSync() {
+	return modelSyncRef;
+}
 /** Schemastery parser for managed DataOps configuration. */
 const Config = z.object({
 	baseUrl: z.string().default("http://host.docker.internal:3101"),
 	serverName: z.string().default("dataops"),
 	credentialRef: z.string().role("credential-ref").default("DATAOPS_ACCESS_TOKEN"),
-	toolCallTimeoutMs: z.number().min(1).default(12e4)
+	toolCallTimeoutMs: z.number().min(1).default(12e4),
+	/**
+	* Volatile so the settings service persists it in this workspace's document. The shape is
+	* left open because the sync state is this plugin's own record, not user configuration.
+	*/
+	modelSync: z.any().default({
+		detached: false,
+		adoptedModelIds: [],
+		privateModelIds: []
+	}).volatile()
 });
 function bearerToken(request) {
 	const authorization = request.headers.authorization?.trim() ?? "";
@@ -59,6 +447,35 @@ async function apply(ctx, config) {
 		if (fiber !== void 0 && fiber.uid !== null) await fiber.dispose();
 	}, "dataops-managed: MCP lifecycle");
 	if (await ctx.credentials.resolve(accessRef) !== void 0) await ensureMcp();
+	const modelSync = new ModelSync(ctx, {
+		baseUrl,
+		credentialRef: config.credentialRef
+	}, {
+		read: () => ({
+			detached: config.modelSync?.detached === true,
+			adoptedModelIds: Array.isArray(config.modelSync?.adoptedModelIds) ? config.modelSync.adoptedModelIds : [],
+			privateModelIds: Array.isArray(config.modelSync?.privateModelIds) ? config.modelSync.privateModelIds : []
+		}),
+		write: async (next) => {
+			await ctx.settings.update(MANAGED_PLUGIN_ID, { modelSync: next });
+		}
+	});
+	modelSyncRef = modelSync;
+	/**
+	* Adopt the publisher's models once the workspace has a session.
+	*
+	* Adoption waits for the JWT because the publication is read with it; a workspace that has
+	* not been authorized yet simply tries again when its session arrives.
+	*/
+	const adoptNow = async () => {
+		try {
+			await modelSync.adopt();
+		} catch (error) {
+			ctx.logger.warn("dataops-managed: model sync could not adopt the published models");
+			ctx.logger.warn(error);
+		}
+	};
+	if (await ctx.credentials.resolve(accessRef) !== void 0) await adoptNow();
 	ctx.effect(() => ctx.webServer.register({
 		kind: "exact",
 		path: MANAGED_AUTH_PATH,
@@ -79,10 +496,94 @@ async function apply(ctx, config) {
 			}
 			await ctx.credentials.set(accessRef, token);
 			await ensureMcp();
+			await adoptNow();
 			response.writeHead(204, { "cache-control": "no-store" });
 			response.end();
 		}
 	}), "dataops-managed: JWT intake route");
+	/**
+	* The settings surface the workspace's own pages read and write.
+	*
+	* Same-origin only: the browser reaches these through the gateway that already authenticated
+	* it, and the DataOps JWT they act with is the one this plugin holds, never a value the page
+	* supplies.
+	*/
+	ctx.effect(() => ctx.webServer.register({
+		kind: "exact",
+		path: MODEL_SYNC_PATH,
+		handler: async (request, response) => {
+			const sync = currentModelSync();
+			if (sync === void 0) {
+				writeJson(response, 503, { error: "model sync is not active" });
+				return;
+			}
+			try {
+				if (request.method === "GET") {
+					writeJson(response, 200, await sync.status());
+					return;
+				}
+				if (request.method !== "POST") {
+					response.writeHead(405, {
+						allow: "GET, POST",
+						"content-length": "0"
+					});
+					response.end();
+					return;
+				}
+				const body = await readJson(request);
+				const action = typeof body?.action === "string" ? body.action : "";
+				if (action === "publish") {
+					const sharingEnabled = body?.sharingEnabled === true;
+					await sync.publish(sharingEnabled);
+					writeJson(response, 200, await sync.status());
+					return;
+				}
+				if (action === "detach") {
+					await sync.detach();
+					writeJson(response, 200, await sync.status());
+					return;
+				}
+				if (action === "resume") {
+					await sync.resumeFollowing();
+					await sync.adopt();
+					writeJson(response, 200, await sync.status());
+					return;
+				}
+				if (action === "private-models") {
+					const ids = Array.isArray(body?.privateModelIds) ? body.privateModelIds.filter((id) => typeof id === "string") : [];
+					await sync.setPrivateModels(ids, body?.sharingEnabled === true);
+					writeJson(response, 200, await sync.status());
+					return;
+				}
+				writeJson(response, 400, { error: "unknown action" });
+			} catch (error) {
+				ctx.logger.warn("dataops-managed: model sync request failed");
+				ctx.logger.warn(error);
+				writeJson(response, 500, { error: error instanceof Error ? error.message : String(error) });
+			}
+		}
+	}), "dataops-managed: model sync routes");
+}
+/** Read and parse a JSON request body, tolerating an absent one. */
+async function readJson(request) {
+	const chunks = [];
+	for await (const chunk of request) chunks.push(chunk);
+	if (chunks.length === 0) return null;
+	try {
+		const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+		return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/** Answer one settings request as JSON. */
+function writeJson(response, status, body) {
+	const payload = JSON.stringify(body);
+	response.writeHead(status, {
+		"content-type": "application/json",
+		"cache-control": "no-store"
+	});
+	response.end(payload);
 }
 //#endregion
-export { Config, MANAGED_AUTH_PATH, apply, inject, name };
+export { Config, MANAGED_AUTH_PATH, MANAGED_PLUGIN_ID, MODEL_SYNC_PATH, apply, currentModelSync, inject, name };

package/lib/types/client/ManagedDataOpsSection.d.ts

@@ -1,5 +1,6 @@
 import type { InjectFace } from '@deepseek-ai/dsh-client-ui-slots';
 import type { en } from './locales.ts';
+import { MODEL_SYNC_PATH } from './model-sync-client.ts';
 /** Values injected by the DSH Settings slot. */
 export interface ManagedDataOpsSectionInjected {
     /** Translate one managed DataOps Settings message key. */
@@ -8,8 +9,10 @@ export interface ManagedDataOpsSectionInjected {
 /** Props accepted by the managed DataOps Settings section. */
 export type ManagedDataOpsSectionProps = Partial<InjectFace<ManagedDataOpsSectionInjected>>;
 /**
- * Explain the DataOps-managed JWT and permission owner without standalone controls.
+ * Explain the DataOps-managed JWT and permission owner, and share model configuration.
  * @param props - Settings slot injection values.
  * @returns The localized managed DataOps section, or nothing before injection.
  */
 export declare function ManagedDataOpsSection(props: ManagedDataOpsSectionProps): import("react").JSX.Element | null;
+/** Re-exported so the settings entry can be discovered from the section alone. */
+export { MODEL_SYNC_PATH };

package/lib/types/client/locales.d.ts

@@ -11,6 +11,24 @@ export declare const en: {
     readonly brandingTitle: "Apply Wanxiang branding";
     readonly brandingDescription: "Use the Wanxiang Data Platform identity in navigation, the New Session welcome view, browser title, and favicon.";
     readonly brandingToggle: "Apply Wanxiang branding";
+    readonly modelsTitle: "Model configuration";
+    readonly modelsDescription: "Share the models configured here with other users, and choose which of them they may use.";
+    readonly modelsUnavailable: "Model configuration is unavailable until this workspace is connected to DataOps.";
+    readonly syncTitle: "Share models with other users";
+    readonly syncDescription: "Other users who have not configured their own models get the models configured here.";
+    readonly syncToggle: "Share models with other users";
+    readonly followTitle: "Using the shared model configuration";
+    readonly followDescription: "The models shared by an administrator are available here. Change them and this workspace keeps your version instead.";
+    readonly detachedTitle: "Using your own model configuration";
+    readonly detachedDescription: "This workspace keeps the models configured here and no longer follows the shared configuration.";
+    readonly resume: "Use the shared configuration again";
+    readonly resuming: "Switching…";
+    readonly noPublisher: "No administrator is sharing models right now.";
+    readonly modelsListTitle: "Models other users may use";
+    readonly modelsListDescription: "A model turned off here stays available in this workspace and is not offered to other users.";
+    readonly modelShareLabel: "Available to other users";
+    readonly modelsEmpty: "No models are configured in this workspace yet. Add them in Models settings first.";
+    readonly loadFailed: "The model configuration could not be loaded. Try again.";
 };
 /** Stable key set shared by every managed DataOps locale. */
 export type ManagedDataOpsKey = keyof typeof en;

package/lib/types/client/model-sync-client.d.ts

@@ -0,0 +1,38 @@
+/** Same-origin model-sync calls from the DataOps settings surface. */
+/** Route the plugin's Host half serves for model sharing. */
+export declare const MODEL_SYNC_PATH = "/integrations/dataops/model-sync";
+/** One model this workspace holds, and whether it is offered to other users. */
+export interface ModelSyncModel {
+    /** Model id as the settings document stores it. */
+    id: string;
+    /** Whether other users may use it. */
+    shared: boolean;
+}
+/** Model sharing as this workspace currently stands. */
+export interface ModelSyncStatus {
+    /** Whether this workspace follows a publisher. */
+    followState: 'following' | 'detached';
+    /** Whether an administrator currently shares models. */
+    publisherSharing: boolean;
+    /** How many models this workspace adopts from the publisher. */
+    adoptedCount: number;
+    /** Model ids kept private. */
+    privateModelIds: string[];
+    /** Publication time, when one is sharing. */
+    publishedAt: string | null;
+    /** Whether the current user may change what this workspace shares. */
+    canPublish: boolean;
+    /** Models this workspace holds. */
+    models: ModelSyncModel[];
+}
+/**
+ * Read the current model sharing state.
+ * @returns The status, or null when this workspace is not connected to DataOps.
+ */
+export declare function fetchModelSyncStatus(): Promise<ModelSyncStatus | null>;
+/**
+ * Change what this workspace shares.
+ * @param body - Action and its parameters.
+ * @returns The status after the change, or null when the plugin is not active.
+ */
+export declare function postModelSyncAction(body: Record<string, unknown>): Promise<ModelSyncStatus | null>;

package/lib/types/index.d.ts

@@ -1,11 +1,18 @@
 /** DataOps-managed JWT intake and credential-backed MCP composition. */
 import type { Context } from '@deepseek-ai/cordis';
 import z from '@deepseek-ai/schemastery';
+import { ModelSync } from './model-sync.ts';
 /** Cordis plugin name for the DataOps-managed integration. */
 export declare const name = "dataops-managed";
 /** Host services required by managed JWT and MCP ownership. */
 export declare const inject: string[];
 export declare const MANAGED_AUTH_PATH = "/integrations/dataops/managed-auth";
+/** This plugin's profile entry id, which owns its Config and sync state. */
+export declare const MANAGED_PLUGIN_ID = "dataops-managed";
+/** Same-origin route the workspace settings pages use to read and change model sharing. */
+export declare const MODEL_SYNC_PATH = "/integrations/dataops/model-sync";
+/** The live model-sync instance, once this plugin activated. */
+export declare function currentModelSync(): ModelSync | undefined;
 /** Configuration for the DataOps-managed MCP connection. */
 export interface Config {
     /** DataOps browser/API origin reachable from the DSH Host. */
@@ -16,6 +23,23 @@ export interface Config {
     credentialRef: string;
     /** Per-tool-call timeout forwarded to the MCP client. */
     toolCallTimeoutMs: number;
+    /**
+     * Model-sync state this workspace keeps.
+     *
+     * Volatile, so the settings service stores it in this workspace's own document. It belongs
+     * to the workspace rather than to DataOps because it records whether the user here wrote
+     * their own models, which is a fact about this workspace.
+     */
+    modelSync: ModelSyncState;
+}
+/** What this workspace remembers about sharing model configuration. */
+export interface ModelSyncState {
+    /** The user here chose their own models, so adoption stops for them. */
+    detached: boolean;
+    /** Model ids adoption last wrote, so a later edit can be told apart from one of them. */
+    adoptedModelIds: string[];
+    /** Model ids the administrator keeps private; every other model is offered by default. */
+    privateModelIds: string[];
 }
 /** Schemastery parser for managed DataOps configuration. */
 export declare const Config: z<Config>;