@datalayer/core 1.1.59 → 1.1.66

package/lib/api/mcp/operations.d.ts

@@ -0,0 +1,83 @@
+export interface McpGatewayVersion {
+    version: string;
+    /** The MCP resource this gateway serves; what a token's `aud` must name. */
+    resource: string;
+}
+export interface McpGatewayHealth {
+    status: string;
+    version: string;
+}
+export type McpWorkerState = 'starting' | 'running' | 'idle' | 'draining' | 'stopped';
+/** One worker process of the directory, keyed by user and by sandbox binding. */
+export interface McpWorker {
+    uid: string;
+    userUid: string;
+    /** The `sb_…` binding whose sandbox this worker holds, when it holds one. */
+    sandboxBindingUid?: string | null;
+    replica: string;
+    state: McpWorkerState;
+    /** Tasks in `working`; a worker with one is never reaped. */
+    workingTasks: number;
+    startedAt: string;
+    lastUsedAt?: string | null;
+    version?: string | null;
+}
+export interface McpWorkerList {
+    items: McpWorker[];
+    /** The replica that answered. */
+    replica?: string;
+}
+export interface McpWorkflowQueue {
+    name: string;
+    backlog: number;
+    /** Seconds the oldest waiting workflow has waited. */
+    oldestWaitSeconds?: number | null;
+}
+/** One periodic job on the replica that answered. */
+export interface McpJob {
+    job: string;
+    /** Ticks this replica actually ran. */
+    ran: number;
+    /**
+     * Ticks this replica skipped because another held the lease. The ordinary
+     * outcome on every replica but one — read it per replica, never summed.
+     * Rising on *all* of them at once is the lease store refusing everybody.
+     */
+    skipped: number;
+    failed: number;
+    lastRanAt?: number | null;
+    lastError?: string;
+    lastDurationSeconds?: number;
+    healthy: boolean;
+}
+export interface McpJobSchedule {
+    /** Whether this replica's scheduler loops are running. */
+    running: boolean;
+    /** The replica that answered; the counts below are only about it. */
+    holder: string;
+    jobs: McpJob[];
+}
+/** Engine health, queue backlog and worker versions. */
+export interface McpWorkflowsHealth {
+    engine: 'temporal' | 'dbos' | string;
+    healthy: boolean;
+    detail?: string | null;
+    queues: McpWorkflowQueue[];
+    workerVersions: Record<string, number>;
+    checkedAt: string;
+}
+export declare const getGatewayVersion: (baseUrl?: string) => Promise<McpGatewayVersion>;
+export declare const getGatewayHealth: (baseUrl?: string) => Promise<McpGatewayHealth>;
+/** The worker directory across replicas; platform administrators only. */
+export declare const listWorkers: (token: string, baseUrl?: string) => Promise<McpWorkerList>;
+export declare const getWorkflowsHealth: (token: string, baseUrl?: string) => Promise<McpWorkflowsHealth>;
+/**
+ * The periodic work on the replica that answers, and what it has done.
+ *
+ * Per replica by construction: only one replica holds each job's lease at a
+ * time, so `ran` on one and `skipped` on the others is the scheduler working.
+ * A caller that wants the platform's view has to ask every replica — there is
+ * no aggregate here, because an aggregate would hide the case worth seeing,
+ * which is every replica skipping at once.
+ */
+export declare const getJobSchedule: (token: string, baseUrl?: string) => Promise<McpJobSchedule>;

package/lib/api/mcp/operations.js

@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2023-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The gateway seen by a platform administrator: its version and liveness,
+ * the worker directory, the engine's health. No raw history, no secrets.
+ *
+ * @module api/mcp/operations
+ */
+import { requestDatalayerAPI } from '../DatalayerApi.js';
+import { DEFAULT_SERVICE_URLS } from '../constants.js';
+import { fromWire, mcpServiceUrl, mcpUrl } from './gateway.js';
+export const getGatewayVersion = async (baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => requestDatalayerAPI({
+    url: mcpServiceUrl(baseUrl, '/version'),
+    method: 'GET',
+});
+export const getGatewayHealth = async (baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => requestDatalayerAPI({
+    url: mcpServiceUrl(baseUrl, '/healthz'),
+    method: 'GET',
+});
+/** The worker directory across replicas; platform administrators only. */
+export const listWorkers = async (token, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, '/operations/workers'),
+    method: 'GET',
+    token,
+}));
+export const getWorkflowsHealth = async (token, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, '/operations/workflows'),
+    method: 'GET',
+    token,
+}));
+/**
+ * The periodic work on the replica that answers, and what it has done.
+ *
+ * Per replica by construction: only one replica holds each job's lease at a
+ * time, so `ran` on one and `skipped` on the others is the scheduler working.
+ * A caller that wants the platform's view has to ask every replica — there is
+ * no aggregate here, because an aggregate would hide the case worth seeing,
+ * which is every replica skipping at once.
+ */
+export const getJobSchedule = async (token, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, '/operations/jobs'),
+    method: 'GET',
+    token,
+}));

package/lib/api/mcp/organizations.d.ts

@@ -0,0 +1,102 @@
+/** One line of the compliance strip: green, or naming what is missing. */
+export interface McpComplianceCheck {
+    /** The rule's name, e.g. `sso_required`, `admitted_clients_only`. */
+    name: string;
+    ok: boolean;
+    /** What is missing, when it is not `ok`. */
+    detail?: string | null;
+}
+/** How many principals act through MCP for the organization. */
+export interface McpOverviewAgents {
+    delegated: number;
+    service: number;
+    activeToday: number;
+}
+export interface McpOverviewRuns {
+    today: number;
+    succeeded: number;
+    failed: number;
+    /** `completed` over terminal tasks; `null` when nothing ran. */
+    successRate?: number | null;
+}
+/** Milestone 3 fills the quota; until then only what was spent is known. */
+export interface McpOverviewSpend {
+    creditsToday: number;
+    creditsMonth: number;
+    quotaMonth?: number | null;
+}
+export interface McpRefusalCount {
+    reason: string;
+    count: number;
+}
+export interface McpOrganizationOverview {
+    orgUid: string;
+    teamUid?: string | null;
+    /** The moment the answer was assembled. */
+    at: string;
+    agents: McpOverviewAgents;
+    runs: McpOverviewRuns;
+    spend?: McpOverviewSpend | null;
+    refusals: McpRefusalCount[];
+    approvalsWaiting?: number | null;
+    alertsFiring?: number | null;
+    compliance: McpComplianceCheck[];
+}
+export interface McpOrganizationOverviewFilters {
+    /** One team of the organization, rather than all of them. */
+    team?: string;
+}
+export declare const getOrganizationMcpOverview: (token: string, orgUid: string, filters?: McpOrganizationOverviewFilters, baseUrl?: string) => Promise<McpOrganizationOverview>;
+/** One quota: what may be used, what is, and the share of the two.
+ *
+ * `used` is `null` where the figure could not be read, with `unknown` saying
+ * why. Absent and unreadable look identical in a dashboard — no number
+ * beside a heading — and mean opposite things: one is "no limit set", the
+ * other is "we cannot tell you what your limit is".
+ */
+export interface McpQuota {
+    limit?: number | null;
+    used?: number | null;
+    /** `used / limit`, computed by the gateway so a page and an alert cannot
+     * divide differently. */
+    fraction?: number | null;
+    /** Why the figure could not be read. Present only when it could not. */
+    unknown?: string;
+}
+/** What one agent spent of the day's credits. */
+export interface McpAgentSpend {
+    /** The MCP client it connected as, e.g. `claude`. Empty for a service
+     * agent reaching Runtimes through the gateway. */
+    clientId: string;
+    /** The service agent's uid, where it is one. */
+    agentUid: string;
+    credits: number;
+    /** Usage records behind the figure. */
+    records: number;
+}
+export interface McpOrganizationUsage {
+    orgUid: string;
+    teamUid?: string | null;
+    window: {
+        seconds: number;
+    };
+    quotas: {
+        creditsPerDay?: McpQuota;
+        concurrentSandboxes?: McpQuota;
+        callsPerMinute?: McpQuota;
+    };
+    /** Which agents the day's credits went to, biggest spender first. Empty
+     * where the total could not be read — the parts under an unreadable whole
+     * make every agent look cheap. */
+    byAgent: McpAgentSpend[];
+    /** Where a limit is changed, which is not here. */
+    setAt: string;
+}
+/**
+ * One organization's use against its quotas, and who spent it.
+ *
+ * Never throws for a figure it could not read: this is a page somebody opens
+ * when something is wrong, and the half of it that works is worth more than
+ * an error saying one number was unavailable.
+ */
+export declare const getOrganizationMcpUsage: (token: string, orgUid: string, filters?: McpOrganizationOverviewFilters, baseUrl?: string) => Promise<McpOrganizationUsage>;

package/lib/api/mcp/organizations.js

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2023-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * What an administrator sees first: the organization's MCP overview.
+ *
+ * One answer for the Enterprise console's Overview page — the agents that
+ * acted today, the runs and their success rate, the refusals by reason, the
+ * approvals waiting and the compliance strip over what IAM knows. Spend,
+ * quota and alerts join the same answer in milestone 3; a field the gateway
+ * does not fill yet is absent rather than zero, so the page can say "not
+ * measured yet" instead of "none".
+ *
+ * `?team=` narrows every part of it to one team.
+ *
+ * @module api/mcp/organizations
+ */
+import { requestDatalayerAPI } from '../DatalayerApi.js';
+import { DEFAULT_SERVICE_URLS } from '../constants.js';
+import { fromWire, mcpUrl } from './gateway.js';
+export const getOrganizationMcpOverview = async (token, orgUid, filters = {}, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, `/organizations/${encodeURIComponent(orgUid)}/overview`, {
+        team: filters.team,
+    }),
+    method: 'GET',
+    token,
+}));
+/**
+ * One organization's use against its quotas, and who spent it.
+ *
+ * Never throws for a figure it could not read: this is a page somebody opens
+ * when something is wrong, and the half of it that works is worth more than
+ * an error saying one number was unavailable.
+ */
+export const getOrganizationMcpUsage = async (token, orgUid, filters = {}, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, `/organizations/${encodeURIComponent(orgUid)}/usage`, {
+        team: filters.team,
+    }),
+    method: 'GET',
+    token,
+}));

package/lib/api/mcp/policy.d.ts

@@ -0,0 +1,9 @@
+import type { McpEffectivePolicy } from '../../models/McpPolicy';
+export type { McpApprovalPolicy, McpEffectivePolicy, McpOrganizationPolicy, McpPersonalPolicy, McpPolicyLayer, McpPolicyRule, McpPolicyScope, McpToolRule, } from '../../models/McpPolicy';
+export interface McpPolicyFilters {
+    /** Preview as: the `client_id` of an agent. */
+    agent?: string;
+    org?: string;
+    team?: string;
+}
+export declare const getEffectivePolicy: (token: string, filters?: McpPolicyFilters, baseUrl?: string) => Promise<McpEffectivePolicy>;

package/lib/api/mcp/policy.js

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2023-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * The effective policy for the caller's token, redacted, each rule naming
+ * the layer that decided it. `?agent=` previews the policy as one agent
+ * would see it.
+ *
+ * @module api/mcp/policy
+ */
+import { requestDatalayerAPI } from '../DatalayerApi.js';
+import { DEFAULT_SERVICE_URLS } from '../constants.js';
+import { fromWire, mcpUrl } from './gateway.js';
+export const getEffectivePolicy = async (token, filters = {}, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, '/policy', { ...filters }),
+    method: 'GET',
+    token,
+}));

package/lib/api/mcp/tasks.d.ts

@@ -0,0 +1,49 @@
+import type { McpTask, McpTaskEvent, McpTaskInput, McpTaskList, McpTaskStatus } from '../../models/McpTask';
+export { MCP_TERMINAL_TASK_STATUSES, isMcpTaskTerminal, } from '../../models/McpTask';
+export type { McpCallToolResult, McpTask, McpTaskEvent, McpTaskInput, McpTaskList, McpTaskOutput, McpTaskStatus, McpWorkflowEngine, } from '../../models/McpTask';
+export interface McpTaskListFilters {
+    notebook?: string;
+    sandbox?: string;
+    /** The `client_id` of the agent, or a service agent's uid. */
+    agent?: string;
+    status?: McpTaskStatus;
+    /** An owner's view of an organization. */
+    org?: string;
+    cursor?: string;
+    limit?: number;
+}
+/** The caller's tasks, newest first; an owner narrows to an organization. */
+export declare const listTasks: (token: string, filters?: McpTaskListFilters, baseUrl?: string) => Promise<McpTaskList>;
+export declare const getTask: (token: string, taskUid: string, baseUrl?: string) => Promise<McpTask>;
+/** Stop a task that is still going. Idempotent: a finished task is answered as it is. */
+export declare const cancelTask: (token: string, taskUid: string, baseUrl?: string) => Promise<McpTask>;
+/**
+ * Answer a task that is `input_required`.
+ *
+ * The input is the tool's own and goes over as typed; only the envelope is
+ * converted. The idempotency key makes a retried answer one answer.
+ */
+export declare const answerTask: (token: string, taskUid: string, request: McpTaskInput, idempotencyKey: string, baseUrl?: string) => Promise<McpTask>;
+/** The tasks of one notebook; empty until milestone 2 fills it. */
+export declare const listNotebookTasks: (token: string, notebookUid: string, filters?: Pick<McpTaskListFilters, "status" | "cursor" | "limit">, baseUrl?: string) => Promise<McpTaskList>;
+/** Where a task's server-sent events are. */
+export declare const taskEventsUrl: (taskUid: string, baseUrl?: string) => string;
+export interface McpTaskEventHandlers {
+    onEvent: (event: McpTaskEvent) => void;
+    onError?: (error: Error) => void;
+    /** The stream ended: the task reached a terminal status or the server closed. */
+    onClose?: () => void;
+}
+/**
+ * One SSE frame as the gateway writes it: `event:` then `data:` lines, a
+ * blank line between frames.
+ */
+export declare const parseTaskEventFrame: (frame: string) => McpTaskEvent | undefined;
+/**
+ * Subscribe to a task's events.
+ *
+ * `EventSource` cannot carry a bearer token, so this reads the stream with
+ * `fetch`. The returned function closes the subscription; the stream also
+ * ends by itself when the task is terminal.
+ */
+export declare const subscribeTaskEvents: (token: string, taskUid: string, handlers: McpTaskEventHandlers, baseUrl?: string) => (() => void);

package/lib/api/mcp/tasks.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright (c) 2023-2025 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/*
+ * Copyright (c) 2023-2026 Datalayer, Inc.
+ * Distributed under the terms of the Modified BSD License.
+ */
+/**
+ * Tasks of the Jupyter MCP Server: submitted by an agent, watched by anyone
+ * allowed to see the notebook.
+ *
+ * `GET /tasks` pages with a cursor and filters on notebook, sandbox, agent
+ * and status; `DELETE /tasks/{uid}` is cancel and is idempotent;
+ * `POST /tasks/{uid}/input` is the REST face of `tasks/update`;
+ * `GET /tasks/{uid}/events` is server-sent events carrying the same
+ * `notifications/tasks` payloads the MCP subscription does.
+ *
+ * @module api/mcp/tasks
+ */
+import { requestDatalayerAPI } from '../DatalayerApi.js';
+import { DEFAULT_SERVICE_URLS } from '../constants.js';
+import { fromWire, mcpUrl } from './gateway.js';
+export { MCP_TERMINAL_TASK_STATUSES, isMcpTaskTerminal, } from '../../models/McpTask.js';
+const taskUrl = (baseUrl, taskUid, suffix = '') => mcpUrl(baseUrl, `/tasks/${encodeURIComponent(taskUid)}${suffix}`);
+/** The filters in the gateway's order, so a key and an URL are stable. */
+const taskQuery = (filters) => ({
+    notebook: filters.notebook,
+    sandbox: filters.sandbox,
+    agent: filters.agent,
+    status: filters.status,
+    org: filters.org,
+    cursor: filters.cursor,
+    limit: filters.limit,
+});
+/** The caller's tasks, newest first; an owner narrows to an organization. */
+export const listTasks = async (token, filters = {}, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, '/tasks', taskQuery(filters)),
+    method: 'GET',
+    token,
+}));
+export const getTask = async (token, taskUid, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: taskUrl(baseUrl, taskUid),
+    method: 'GET',
+    token,
+}));
+/** Stop a task that is still going. Idempotent: a finished task is answered as it is. */
+export const cancelTask = async (token, taskUid, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: taskUrl(baseUrl, taskUid),
+    method: 'DELETE',
+    token,
+}));
+/**
+ * Answer a task that is `input_required`.
+ *
+ * The input is the tool's own and goes over as typed; only the envelope is
+ * converted. The idempotency key makes a retried answer one answer.
+ */
+export const answerTask = async (token, taskUid, request, idempotencyKey, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: taskUrl(baseUrl, taskUid, '/input'),
+    method: 'POST',
+    token,
+    headers: { 'Idempotency-Key': idempotencyKey },
+    body: { input: request.input },
+}));
+/** The tasks of one notebook; empty until milestone 2 fills it. */
+export const listNotebookTasks = async (token, notebookUid, filters = {}, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => fromWire(await requestDatalayerAPI({
+    url: mcpUrl(baseUrl, `/notebooks/${encodeURIComponent(notebookUid)}/tasks`, taskQuery(filters)),
+    method: 'GET',
+    token,
+}));
+/** Where a task's server-sent events are. */
+export const taskEventsUrl = (taskUid, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => taskUrl(baseUrl, taskUid, '/events');
+/**
+ * One SSE frame as the gateway writes it: `event:` then `data:` lines, a
+ * blank line between frames.
+ */
+export const parseTaskEventFrame = (frame) => {
+    let event = 'message';
+    const data = [];
+    for (const line of frame.split(/\r?\n/)) {
+        if (line.startsWith('event:')) {
+            event = line.slice('event:'.length).trim();
+        }
+        else if (line.startsWith('data:')) {
+            data.push(line.slice('data:'.length).replace(/^ /, ''));
+        }
+    }
+    if (data.length === 0) {
+        return undefined;
+    }
+    const payload = fromWire(JSON.parse(data.join('\n')));
+    return { ...payload, event: payload.event ?? event, taskId: payload.taskId ?? '' };
+};
+/**
+ * Subscribe to a task's events.
+ *
+ * `EventSource` cannot carry a bearer token, so this reads the stream with
+ * `fetch`. The returned function closes the subscription; the stream also
+ * ends by itself when the task is terminal.
+ */
+export const subscribeTaskEvents = (token, taskUid, handlers, baseUrl = DEFAULT_SERVICE_URLS.JUPYTER_MCP_SERVER) => {
+    const controller = new AbortController();
+    const run = async () => {
+        const response = await fetch(taskEventsUrl(taskUid, baseUrl), {
+            headers: { Authorization: `Bearer ${token}`, Accept: 'text/event-stream' },
+            signal: controller.signal,
+        });
+        if (!response.ok || !response.body) {
+            throw new Error(`Task events refused: ${response.status} ${response.statusText}`);
+        }
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffered = '';
+        for (;;) {
+            const { value, done } = await reader.read();
+            if (done) {
+                break;
+            }
+            buffered += decoder.decode(value, { stream: true });
+            let boundary = buffered.indexOf('\n\n');
+            while (boundary >= 0) {
+                const frame = buffered.slice(0, boundary);
+                buffered = buffered.slice(boundary + 2);
+                const event = parseTaskEventFrame(frame);
+                if (event) {
+                    handlers.onEvent(event);
+                }
+                boundary = buffered.indexOf('\n\n');
+            }
+        }
+        const last = parseTaskEventFrame(buffered);
+        if (last) {
+            handlers.onEvent(last);
+        }
+    };
+    run()
+        .then(() => handlers.onClose?.())
+        .catch((error) => {
+        if (controller.signal.aborted) {
+            handlers.onClose?.();
+            return;
+        }
+        handlers.onError?.(error instanceof Error ? error : new Error(String(error)));
+    });
+    return () => controller.abort();
+};

package/lib/api/utils/validation.d.ts

@@ -37,7 +37,7 @@ export declare const validateRequiredString: (value: string | undefined | null,
  * ```typescript
  * const runtimeData = {
  *   uid: 'abc123',
- *   podName: 'my-pod',
+ *   runtimeName: 'runtime-abc123',
  *   environmentName: undefined  // This will throw
  * };
  * validateJSON(runtimeData, 'Runtime');

package/lib/api/utils/validation.js

@@ -146,7 +146,7 @@ export const validateRequiredString = (value, paramName) => {
  * ```typescript
  * const runtimeData = {
  *   uid: 'abc123',
- *   podName: 'my-pod',
+ *   runtimeName: 'runtime-abc123',
  *   environmentName: undefined  // This will throw
  * };
  * validateJSON(runtimeData, 'Runtime');

package/lib/client/auth/index.js

@@ -2,11 +2,6 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- *
- * Datalayer License
- */
 /**
  * Authentication module for Datalayer Client
  * Provides unified authentication interface with multiple strategies

package/lib/client/auth/storage.js

@@ -2,11 +2,6 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- *
- * Datalayer License
- */
 /**
  * Token storage backend implementations
  */

package/lib/client/auth/strategies.js

@@ -2,11 +2,6 @@
  * Copyright (c) 2023-2025 Datalayer, Inc.
  * Distributed under the terms of the Modified BSD License.
  */
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- *
- * Datalayer License
- */
 /**
  * Authentication strategy implementations
  */

package/lib/client/base.d.ts

@@ -19,6 +19,8 @@ export interface DatalayerClientConfig {
     runtimesUrl?: string;
     /** URL for the Spacer service */
     spacerUrl?: string;
+    /** URL for the Contents service */
+    contentsUrl?: string;
     /** Custom token storage backend (optional, defaults to auto-detected) */
     storage?: TokenStorage;
     /** Handlers for intercepting Client method calls */
@@ -32,6 +34,8 @@ export declare class DatalayerClientBase {
     readonly runtimesUrl: string;
     /** URL for Spacer service */
     readonly spacerUrl: string;
+    /** URL for Contents service */
+    readonly contentsUrl: string;
     /** Authentication token */
     token?: string;
     /** Method lifecycle handlers */
@@ -54,6 +58,8 @@ export declare class DatalayerClientBase {
     getRuntimesUrl(): string;
     /** Get the Spacer service URL. */
     getSpacerUrl(): string;
+    /** Get the Contents service URL. */
+    getContentsUrl(): string;
     /** Get the current authentication token. */
     getToken(): string | undefined;
     /**

package/lib/client/base.js

@@ -16,6 +16,8 @@ export class DatalayerClientBase {
     runtimesUrl;
     /** URL for Spacer service */
     spacerUrl;
+    /** URL for Contents service */
+    contentsUrl;
     /** Authentication token */
     token;
     /** Method lifecycle handlers */
@@ -31,6 +33,7 @@ export class DatalayerClientBase {
         this.runtimesUrl =
             config.runtimesUrl || DEFAULT_SERVICE_URLS.RUNTIMES;
         this.spacerUrl = config.spacerUrl || DEFAULT_SERVICE_URLS.SPACER;
+        this.contentsUrl = config.contentsUrl || DEFAULT_SERVICE_URLS.CONTENTS;
         this.token = config.token;
         this.handlers = config.handlers;
         // Initialize authentication manager with custom storage if provided
@@ -49,6 +52,7 @@ export class DatalayerClientBase {
             iamUrl: this.iamUrl,
             runtimesUrl: this.runtimesUrl,
             spacerUrl: this.spacerUrl,
+            contentsUrl: this.contentsUrl,
             token: this.token,
         };
     }
@@ -64,6 +68,10 @@ export class DatalayerClientBase {
     getSpacerUrl() {
         return this.spacerUrl;
     }
+    /** Get the Contents service URL. */
+    getContentsUrl() {
+        return this.contentsUrl;
+    }
     /** Get the current authentication token. */
     getToken() {
         return this.token;

package/lib/client/index.d.ts

@@ -20,8 +20,6 @@ import type { CreditsDTO } from '../models/CreditsDTO';
 import type { HealthCheck } from '../models/HealthCheck';
 import type { SecretDTO } from '../models/Secret';
 import type { CreateSecretRequest, UpdateSecretRequest } from '../models/Secret';
-import type { DatasourceDTO } from '../models/Datasource';
-import type { CreateDatasourceRequest, UpdateDatasourceRequest } from '../models/Datasource';
 declare const DatalayerCoreClientWithMixins: typeof DatalayerClientBase;
 /**
  * Core Datalayer Client providing access to identity, plans and account
@@ -57,13 +55,10 @@ export { HealthCheck } from '../models/HealthCheck';
 export type { HealthCheckJSON } from '../models/HealthCheck';
 export { SecretDTO as Secret } from './../models/Secret';
 export type { SecretJSON, SecretData, CreateSecretRequest, UpdateSecretRequest, CreateSecretResponse, GetSecretResponse, ListSecretsResponse, UpdateSecretResponse, DeleteSecretResponse, } from './../models/Secret';
-export { DatasourceDTO as Datasource } from './../models/Datasource';
-export type { DatasourceJSON, DatasourceData, DatasourceType, CreateDatasourceRequest, UpdateDatasourceRequest, CreateDatasourceResponse, GetDatasourceResponse, ListDatasourcesResponse, UpdateDatasourceResponse, } from './../models/Datasource';
 export type { LoginRequest, LoginResponse, UserMeResponse, MembershipsResponse, WhoAmIResponse, } from '../models/IAM';
 export type { HealthzPingResponse } from '../models/Common';
 export { AuthenticationManager } from './auth/AuthenticationManager';
 export type { IUser, IBaseUser } from '../models/User';
-export type { IDatasource, IDatasourceVariant } from '../models/Datasource';
 export type { ICredits, ICreditsReservation } from '../models/Credits';
 export type { ISurvey } from '../models/Survey';
 export type { IBaseTeam, IAnyTeam } from '../models/Team';
@@ -111,10 +106,5 @@ export interface DatalayerCoreClient {
     getSecret(secretId: string): Promise<SecretDTO>;
     updateSecret(secretId: string, updates: UpdateSecretRequest): Promise<SecretDTO>;
     deleteSecret(secretId: string): Promise<void>;
-    createDatasource(data: CreateDatasourceRequest): Promise<DatasourceDTO>;
-    listDatasources(): Promise<DatasourceDTO[]>;
-    getDatasource(datasourceId: string): Promise<DatasourceDTO>;
-    updateDatasource(datasourceId: string, updates: UpdateDatasourceRequest): Promise<DatasourceDTO>;
-    deleteDatasource(datasourceId: string): Promise<void>;
     calculateCreditsFromMinutes(minutes: number, burningRate: number): number;
 }