@chengxianglibra/dsh-data-analysis 0.1.2 → 0.2.1

package/lib/datasource/rpc.js

@@ -1,19 +1,34 @@
 import { z } from 'zod';
+import { registerPluginRpc } from "../rpc.js";
+import { withDatasourceDefaults } from "./defaults.js";
 import { CREDENTIAL_CHANNEL, credentialError } from "./service.js";
 const text = z.string().min(1).max(256);
 const handle = { generation: z.string().uuid(), id: z.string().uuid(), scope: z.string().uuid() };
 const mutation = z
     .object({
     ...handle,
-    action: z.enum(['save', 'update', 'delete', 'test', 'submit', 'diagnose']),
+    action: z.enum(['save', 'update', 'delete', 'delete-datasource', 'test', 'submit', 'diagnose']),
+    deleteCredentials: z.boolean().optional(),
     version: z.string().max(65536),
     requestId: z.string().uuid().optional(),
     reference: text.optional(),
     changes: z.record(text, z.string().min(1).max(65536)).optional(),
 })
     .strict();
-export function registerCredentialRpc(connection, service, workspace) {
-    const unregister = connection.rpc.handle(CREDENTIAL_CHANNEL, async (endpoint, payload, signal) => {
+export function registerCredentialRpc(connection, service, workspace, datasourceDefaults) {
+    const unregister = registerPluginRpc(connection, CREDENTIAL_CHANNEL, [
+        'overview',
+        'authoring',
+        'create-datasource',
+        'configuration',
+        'update-datasource',
+        'select-configuration',
+        'watch',
+        'start',
+        'operation',
+        'cancel-operation',
+        'cancel-request',
+    ], async (endpoint, payload, signal) => {
         try {
             if (Buffer.byteLength(JSON.stringify(payload) ?? '') > 1_048_576)
                 throw new Error('invalid-request');
@@ -26,24 +41,74 @@ export function registerCredentialRpc(connection, service, workspace) {
                 };
             }
             else if (endpoint === 'authoring') {
-                const input = z.object({ workspaceId: text }).strict().parse(payload);
+                const input = z
+                    .object({ workspaceId: text, mode: z.enum(['create', 'edit']).default('create') })
+                    .strict()
+                    .parse(payload);
                 const bridge = await workspace(input.workspaceId);
                 if (!bridge.authoring)
                     throw new Error('authoring-unavailable');
-                value = { generation: service.generation, ...(await bridge.authoring(signal)) };
+                const schema = await bridge.authoring(signal);
+                value = {
+                    generation: service.generation,
+                    ...(input.mode === 'edit'
+                        ? schema
+                        : withDatasourceDefaults(schema, datasourceDefaults)),
+                };
             }
-            else if (endpoint === 'create-datasource') {
+            else if (endpoint === 'configuration') {
+                const input = z.object({ workspaceId: text, name: text }).strict().parse(payload);
+                const bridge = await workspace(input.workspaceId);
+                if (!bridge.configuration)
+                    throw new Error('authoring-unavailable');
+                value = await bridge.configuration(input.name, signal);
+            }
+            else if (endpoint === 'select-configuration') {
+                const input = z
+                    .object({ workspaceId: text, requestId: z.string().uuid(), name: text })
+                    .strict()
+                    .parse(payload);
+                value = await service.selectConfiguration(input.requestId, input.workspaceId, input.name, () => workspace(input.workspaceId), signal);
+            }
+            else if (endpoint === 'create-datasource' || endpoint === 'update-datasource') {
                 const input = z
                     .object({
                     workspaceId: text,
                     generation: z.string().uuid(),
                     fingerprint: z.string().min(1).max(256),
                     backend: text,
+                    name: text.optional(),
+                    version: text.optional(),
+                    requestId: z.string().uuid().optional(),
                     fields: z.record(text, z.unknown()),
                 })
                     .strict()
                     .parse(payload);
-                value = await service.createDatasource(input.generation, input.fingerprint, input, () => workspace(input.workspaceId), signal);
+                const request = input.requestId
+                    ? await service.configurationRequest(input.requestId, input.workspaceId, () => workspace(input.workspaceId), signal)
+                    : undefined;
+                const operationSignal = request ? AbortSignal.any([signal, request.signal]) : signal;
+                const resolve = async () => {
+                    if (input.requestId)
+                        await service.configurationRequest(input.requestId, input.workspaceId, () => workspace(input.workspaceId), operationSignal);
+                    return workspace(input.workspaceId);
+                };
+                if (endpoint === 'update-datasource') {
+                    const { name, version } = z.object({ name: text, version: text }).parse(input);
+                    if (request?.view.configuration.mode === 'edit' &&
+                        request.view.configuration.name !== name)
+                        throw new Error('invalid-request');
+                    value = await service.updateDatasource(input.generation, input.fingerprint, { backend: input.backend, fields: input.fields, name, version }, resolve, operationSignal);
+                }
+                else {
+                    if (input.name || input.version || request?.view.configuration.mode === 'edit')
+                        throw new Error('invalid-request');
+                    value = await service.createDatasource(input.generation, input.fingerprint, { backend: input.backend, fields: input.fields }, resolve, operationSignal);
+                }
+                if (input.requestId) {
+                    const configured = await service.selectConfiguration(input.requestId, input.workspaceId, value.name, () => workspace(input.workspaceId), operationSignal);
+                    value = { ...value, request: configured };
+                }
             }
             else if (endpoint === 'watch') {
                 const input = z
@@ -79,10 +144,7 @@ export function registerCredentialRpc(connection, service, workspace) {
                 error: { code: 'internal', message: credentialError(error), details: {} },
             };
         }
-    }, { authority: 'trusted-host' });
-    return async () => {
-        const draining = unregister();
-        await service.close();
-        await draining;
-    };
+    });
+    // The profile owns this shared service; withdrawing its Web entry must not close it.
+    return unregister;
 }

package/lib/datasource/service.js

@@ -1,9 +1,18 @@
 import { randomUUID } from 'node:crypto';
 import { credentialRef } from '@deepseek-ai/dsh-credentials';
+import { finishCleanup } from "../lifecycle.js";
 import { marivoCredentialStorageRef } from "./shell-env.js";
 export const CREDENTIAL_CHANNEL = '/dsh-data-analysis-credentials';
 const RETENTION = 30 * 60_000;
 const CAPACITY = 512;
+function sessionIdentity(exec) {
+    const session = exec.agent.session;
+    return JSON.stringify([
+        session.id,
+        Reflect.get(session.header, 'workspaceId'),
+        session.header.cwd,
+    ]);
+}
 export class CredentialServiceError extends Error {
     code;
     constructor(code) {
@@ -24,9 +33,12 @@ export class MarivoCredentialService {
     generation = randomUUID();
     #store;
     #contexts = new Map();
+    #activeContexts = new Set();
+    #configurations = new Map();
     #requests = new Map();
     #operations = new Map();
     #controllers = new Map();
+    #closing;
     #tasks = new Set();
     #versions = new Map();
     #activeRefs = new Map();
@@ -68,6 +80,9 @@ export class MarivoCredentialService {
         for (const [id, op] of this.#operations)
             if (op.endedAt !== undefined && now - op.endedAt >= RETENTION)
                 this.#operations.delete(id);
+        for (const [id, request] of this.#configurations)
+            if (request.view.endedAt !== undefined && now - request.view.endedAt >= RETENTION)
+                this.#configurations.delete(id);
         for (const [id, request] of this.#requests)
             if (request.view.endedAt !== undefined && now - request.view.endedAt >= RETENTION)
                 this.#requests.delete(id);
@@ -128,11 +143,13 @@ export class MarivoCredentialService {
         this.#changed();
     }
     async #current(context, signal) {
+        assert(!context.invalidated, 'context-changed');
         signal.throwIfAborted();
         const bridge = await context.resolve();
         assert(bridge.binding.fingerprint === context.bridge.binding.fingerprint, 'context-changed');
         const described = await bridge.describe(context.description.name, signal);
         assert(described.definition === context.description.definition, 'context-changed');
+        assert(!context.invalidated, 'context-changed');
         signal.throwIfAborted();
         context.touched = this.now();
     }
@@ -146,7 +163,12 @@ export class MarivoCredentialService {
                 throw new CredentialServiceError('credential-state-unavailable');
             }
         }
-        const history = this.#history.get(this.#historyKey(context));
+        const historyKey = this.#historyKey(context);
+        const previous = [...this.#history.entries()].reverse().find(([key]) => {
+            const [fingerprint, name] = JSON.parse(key);
+            return fingerprint === context.bridge.binding.fingerprint && name === context.description.name;
+        });
+        const history = this.#history.get(historyKey) ?? previous?.[1];
         return {
             token: context.token,
             workspaceId: context.workspaceId,
@@ -162,7 +184,7 @@ export class MarivoCredentialService {
                     lastTest: {
                         at: history.at,
                         result: history.result,
-                        stale: history.version !== this.#version(context),
+                        stale: !this.#history.has(historyKey) || history.version !== this.#version(context),
                     },
                 }
                 : {}),
@@ -207,7 +229,8 @@ export class MarivoCredentialService {
                 resolve,
                 touched: this.now(),
             };
-            const old = [...this.#contexts.values()].find((c) => c.workspaceId === workspaceId &&
+            const old = [...this.#contexts.values()].find((c) => !c.invalidated &&
+                c.workspaceId === workspaceId &&
                 c.description.name === context.description.name &&
                 c.description.definition === context.description.definition &&
                 c.bridge.binding.fingerprint === context.bridge.binding.fingerprint);
@@ -234,9 +257,147 @@ export class MarivoCredentialService {
             signal.throwIfAborted();
             const result = await bridge.create(input, signal);
             assert(!result.error && result.name, result.error ?? 'datasource-definition-invalid');
+            this.#changed();
             return { name: result.name };
         }, signal);
     }
+    async updateDatasource(generation, fingerprint, input, resolve, caller) {
+        const signal = AbortSignal.any([caller, this.#lifetime.signal]);
+        return this.#locked(async () => {
+            assert(generation === this.generation, 'context-changed');
+            const bridge = await resolve();
+            assert(bridge.binding.fingerprint === fingerprint, 'context-changed');
+            assert(bridge.update, 'datasource-authoring-unavailable');
+            assert(![...this.#operations.values()].some((op) => op.status === 'running' &&
+                this.#contexts.get(op.scope)?.bridge.binding.fingerprint === fingerprint &&
+                this.#contexts.get(op.scope)?.description.name === input.name), 'operation-busy');
+            const result = await bridge.update(input, signal);
+            assert(!result.error && result.name, result.error ?? 'datasource-definition-invalid');
+            this.#changed();
+            return { name: result.name };
+        }, signal);
+    }
+    async configure(exec, resolve, input) {
+        assert(exec.agent, 'agent-required');
+        assert((input.mode === 'create' && input.name === undefined) ||
+            (input.mode === 'edit' &&
+                typeof input.name === 'string' &&
+                !!input.name.trim() &&
+                input.name.length <= 256), 'invalid-request');
+        assert(typeof input.reason === 'string' && !!input.reason.trim() && input.reason.length <= 1000, 'invalid-request');
+        const agent = exec.agent;
+        if (this.interaction === 'none' ||
+            agent.session.header.origin === 'subagent' ||
+            (agent.session.header.delegationDepth ?? 0) > 0)
+            return { status: 'needs-configuration', ...(input.name ? { name: input.name } : {}) };
+        const controller = new AbortController();
+        const signal = AbortSignal.any([this.executionSignal(exec.signal, agent), controller.signal]);
+        const identity = sessionIdentity(exec);
+        const bridge = await resolve();
+        signal.throwIfAborted();
+        assert(identity === sessionIdentity(exec), 'context-changed');
+        this.#prune();
+        assert(this.#configurations.size < CAPACITY / 2, 'capacity-exceeded');
+        return new Promise((finish) => {
+            const id = randomUUID();
+            const request = {
+                exec,
+                settled: false,
+                controller,
+                resolve,
+                fingerprint: bridge.binding.fingerprint,
+                sessionIdentity: identity,
+                signal,
+                finish,
+                view: {
+                    id,
+                    sessionId: agent.session.id,
+                    workspaceId: String(Reflect.get(agent.session.header, 'workspaceId') ?? ''),
+                    configuration: { ...input },
+                    status: 'awaiting-input',
+                },
+                stop: () => signal.removeEventListener('abort', abort),
+            };
+            const abort = () => this.#endConfiguration(request, { status: 'call-ended' });
+            this.#configurations.set(id, request);
+            signal.addEventListener('abort', abort, { once: true });
+            if (signal.aborted)
+                abort();
+            this.#changed();
+        });
+    }
+    #endConfiguration(request, result) {
+        if (request.settled)
+            return;
+        request.settled = true;
+        request.view.endedAt = this.now();
+        request.view.status =
+            result.status === 'ok'
+                ? 'succeeded'
+                : result.status === 'failed'
+                    ? 'handed-off'
+                    : result.status === 'context-changed'
+                        ? 'context-changed'
+                        : result.status === 'cancelled'
+                            ? 'cancelled'
+                            : 'call-ended';
+        request.stop();
+        request.finish(result);
+        this.#changed();
+    }
+    async #configurationCurrent(request, signal) {
+        assert(request.view.endedAt === undefined && !request.signal.aborted, 'call-ended');
+        signal.throwIfAborted();
+        const bridge = await request.resolve();
+        assert(bridge.binding.fingerprint === request.fingerprint &&
+            sessionIdentity(request.exec) === request.sessionIdentity, 'context-changed');
+        return bridge;
+    }
+    async configurationRequest(id, workspaceId, resolve, caller) {
+        const request = this.#configurations.get(id);
+        assert(request, 'call-ended');
+        const bridge = await this.#configurationCurrent(request, caller);
+        assert((!request.view.workspaceId || request.view.workspaceId === workspaceId) &&
+            (await resolve()).binding.fingerprint === bridge.binding.fingerprint, 'context-changed');
+        assert(request.view.status !== 'executing', 'operation-busy');
+        return request;
+    }
+    async selectConfiguration(id, workspaceId, name, resolve, caller) {
+        const request = await this.configurationRequest(id, workspaceId, resolve, caller);
+        assert(request.view.configuration.mode !== 'edit' || request.view.configuration.name === name, 'datasource-identity-fixed');
+        const signal = AbortSignal.any([caller, request.signal]);
+        const context = await this.#bind(workspaceId, request.resolve, name, signal);
+        const view = await this.#view(context);
+        await this.#configurationCurrent(request, signal);
+        assert(request.view.status !== 'executing', 'operation-busy');
+        assert(this.#contexts.size < CAPACITY, 'capacity-exceeded');
+        this.#contexts.set(context.token, context);
+        request.view.context = view;
+        request.view.status = 'awaiting-input';
+        delete request.view.failure;
+        // Once a datasource is chosen, use the existing credential/test operation lifecycle.
+        const attached = {
+            view: request.view,
+            context,
+            exec: request.exec,
+            signal: request.signal,
+            stop: () => { },
+            finish: ({ result }) => {
+                this.#endConfiguration(request, {
+                    status: result.ok ? 'ok' : 'failed',
+                    name: result.name,
+                    latency_ms: result.latency_ms,
+                    ...(!result.ok ? { failure: result.failure, repair: result.repair } : {}),
+                });
+            },
+            reject: () => {
+                this.#endConfiguration(request, { status: 'context-changed' });
+            },
+        };
+        this.#requests.set(id, attached);
+        this.#changed();
+        return structuredClone(request.view);
+    }
     #watchRefs(refs) {
         const unique = new Set(refs);
         for (const ref of unique)
@@ -359,6 +520,7 @@ export class MarivoCredentialService {
         assert(exec.agent, 'agent-required');
         const signal = this.executionSignal(exec.signal, exec.agent);
         const context = await this.#bind('', resolve, name, signal);
+        this.#activeContexts.add(context);
         const stop = this.#watchRefs(context.description.refs);
         try {
             const tested = await this.#awaitCredentials(exec, context, await this.#view(context), signal);
@@ -370,6 +532,7 @@ export class MarivoCredentialService {
         }
         finally {
             stop();
+            this.#activeContexts.delete(context);
         }
     }
     async prepareExecution(exec, resolve, names) {
@@ -394,6 +557,8 @@ export class MarivoCredentialService {
                 delete values[ref];
             for (const stop of stops)
                 stop();
+            for (const context of contexts)
+                this.#activeContexts.delete(context);
         };
         try {
             for (const name of names) {
@@ -401,6 +566,7 @@ export class MarivoCredentialService {
                 assert(!contexts.length ||
                     context.bridge.binding.fingerprint === contexts[0].bridge.binding.fingerprint, 'context-changed');
                 contexts.push(context);
+                this.#activeContexts.add(context);
                 stops.push(this.#watchRefs(context.description.refs));
                 const view = await this.#view(context);
                 if (view.refs.every((ref) => view.credentials[ref]?.configured))
@@ -425,8 +591,10 @@ export class MarivoCredentialService {
                 assert(!released, 'execution-ended');
                 signal.throwIfAborted();
                 assert(exec.agent?.session === session && currentWorkspace() === workspace, 'context-changed');
-                for (const context of contexts)
+                for (const context of contexts) {
+                    assert(!context.invalidated, 'context-changed');
                     assert(versions.get(context) === this.#version(context), 'credentials-changed');
+                }
             };
             assertCurrent();
             values = await this.#snapshot(contexts, signal);
@@ -459,9 +627,12 @@ export class MarivoCredentialService {
         return {
             generation: this.generation,
             cursor: `${this.generation}:${this.#revision}`,
-            requests: [...this.#requests.values()]
+            configurationRequests: [...this.#configurations.values()]
                 .filter((r) => r.view.sessionId === sessionId)
                 .map((r) => structuredClone(r.view)),
+            requests: [...this.#requests.values()]
+                .filter((r) => r.view.sessionId === sessionId && !this.#configurations.has(r.view.id))
+                .map((r) => structuredClone(r.view)),
         };
     }
     async waitWatch(sessionId, cursor, signal) {
@@ -483,6 +654,17 @@ export class MarivoCredentialService {
             });
         }
         signal.throwIfAborted();
+        for (const request of this.#configurations.values()) {
+            if (request.view.sessionId !== sessionId || request.view.endedAt !== undefined)
+                continue;
+            try {
+                await this.#configurationCurrent(request, signal);
+            }
+            catch {
+                if (!signal.aborted)
+                    this.#endConfiguration(request, { status: 'context-changed' });
+            }
+        }
         for (const request of this.#requests.values()) {
             if (request.view.sessionId !== sessionId || request.view.endedAt !== undefined)
                 continue;
@@ -513,14 +695,20 @@ export class MarivoCredentialService {
         assert(this.#operations.size < CAPACITY, 'capacity-exceeded');
         const context = this.#contexts.get(input.scope);
         assert(context, 'context-changed');
+        assert(!context.invalidated, 'context-changed');
+        assert(input.action === 'delete-datasource' || input.deleteCredentials === undefined, 'invalid-action');
         const request = input.requestId ? this.#requests.get(input.requestId) : undefined;
         assert(!input.requestId ||
             (request &&
-                request.context === context &&
+                request.context.token === context.token &&
                 request.view.endedAt === undefined &&
                 !request.signal.aborted), 'call-ended');
         assert((input.action === 'submit' || input.action === 'diagnose') === !!request, 'invalid-action');
-        assert(![...this.#operations.values()].some((op) => op.scope === input.scope && op.status === 'running'), 'operation-busy');
+        assert(![...this.#operations.values()].some((op) => op.status === 'running' &&
+            (op.scope === input.scope ||
+                (this.#contexts.get(op.scope)?.bridge.binding.fingerprint ===
+                    context.bridge.binding.fingerprint &&
+                    this.#contexts.get(op.scope)?.description.name === context.description.name))), 'operation-busy');
         if (request)
             assert(request.view.status !== 'executing', 'operation-busy');
         assert(input.version === this.#version(context), 'credentials-changed');
@@ -543,6 +731,9 @@ export class MarivoCredentialService {
             phase: 'saving',
             saved: [],
             errors: [],
+            ...(input.action === 'delete-datasource'
+                ? { deleteCredentials: input.deleteCredentials === true }
+                : {}),
         };
         this.#operations.set(op.id, op);
         const controller = new AbortController();
@@ -565,7 +756,70 @@ export class MarivoCredentialService {
     async #run(context, request, op, changes, reference, version, signal) {
         try {
             await this.#current(context, signal);
-            if (op.action === 'diagnose') {
+            const configuration = request && this.#configurations.get(request.view.id);
+            if (configuration)
+                await this.#configurationCurrent(configuration, signal);
+            if (op.action === 'delete-datasource') {
+                await this.#locked(async () => {
+                    await this.#current(context, signal);
+                    assert(version === this.#version(context), 'credentials-changed');
+                    assert(context.bridge.remove, 'datasource-remove-unavailable');
+                    op.phase = 'removing';
+                    // Revoke pending uses even if the subprocess result is later lost.
+                    for (const bound of new Set([
+                        ...this.#contexts.values(),
+                        ...this.#activeContexts,
+                        ...[...this.#requests.values()].map((pending) => pending.context),
+                    ])) {
+                        if (bound.bridge.binding.fingerprint !== context.bridge.binding.fingerprint ||
+                            bound.description.name !== context.description.name)
+                            continue;
+                        bound.invalidated = true;
+                    }
+                    for (const pending of this.#requests.values()) {
+                        if (!pending.context.invalidated || pending.view.endedAt !== undefined)
+                            continue;
+                        pending.view.status = 'context-changed';
+                        pending.view.endedAt = this.now();
+                        pending.stop();
+                        pending.reject(new CredentialServiceError('context-changed'));
+                    }
+                    for (const pending of this.#configurations.values()) {
+                        if (pending.fingerprint === context.bridge.binding.fingerprint &&
+                            (pending.view.context?.name === context.description.name ||
+                                (pending.view.configuration.mode === 'edit' &&
+                                    pending.view.configuration.name === context.description.name)))
+                            this.#endConfiguration(pending, { status: 'context-changed' });
+                    }
+                    this.#changed();
+                    const result = await context.bridge.remove(context.description, signal);
+                    assert(!result.error && result.name === context.description.name, result.error ?? 'datasource-remove-failed');
+                    op.datasourceRemoved = true;
+                    for (const key of this.#history.keys()) {
+                        const [fingerprint, name] = JSON.parse(key);
+                        if (fingerprint === context.bridge.binding.fingerprint &&
+                            name === context.description.name)
+                            this.#history.delete(key);
+                    }
+                    if (op.deleteCredentials) {
+                        op.deletedCredentials = [];
+                        op.credentialDeleteFailures = [];
+                        for (const ref of new Set(context.description.refs)) {
+                            signal.throwIfAborted();
+                            this.invalidate([ref]);
+                            try {
+                                await this.#store.unset(credentialRef(marivoCredentialStorageRef(ref)));
+                                op.deletedCredentials.push(ref);
+                            }
+                            catch {
+                                op.credentialDeleteFailures.push(ref);
+                            }
+                        }
+                        assert(op.credentialDeleteFailures.length === 0, 'credential-delete-failed');
+                    }
+                }, signal);
+            }
+            else if (op.action === 'diagnose') {
                 assert(request?.view.failure, 'no-test-failure');
                 op.result = request.view.failure;
                 request.view.status = 'handed-off';
@@ -606,6 +860,9 @@ export class MarivoCredentialService {
                     if (request && request.view.endedAt === undefined) {
                         request.view.context = await this.#view(context);
                         signal.throwIfAborted();
+                        await this.#current(context, signal);
+                        if (configuration)
+                            await this.#configurationCurrent(configuration, signal);
                         assert(testedVersion === this.#version(context), 'credentials-changed');
                         if (op.result.ok) {
                             request.view.status = 'succeeded';
@@ -657,6 +914,16 @@ export class MarivoCredentialService {
         this.#controllers.get(id)?.abort();
     }
     cancelRequest(id) {
+        const configuration = this.#configurations.get(id);
+        if (configuration) {
+            assert(configuration.view.endedAt === undefined, 'call-ended');
+            for (const op of this.#operations.values())
+                if (op.scope === configuration.view.context?.token && op.status === 'running')
+                    this.#controllers.get(op.id)?.abort();
+            this.#endConfiguration(configuration, { status: 'cancelled' });
+            configuration.controller.abort();
+            return;
+        }
         const request = this.#requests.get(id);
         assert(request && request.view.endedAt === undefined && !request.signal.aborted, 'call-ended');
         request.exec.agent.cancel({ kind: 'user' }, { keepInbox: true });
@@ -679,9 +946,17 @@ export class MarivoCredentialService {
         this.#tasks.add(tracked);
         return task;
     }
-    async close() {
+    close() {
+        if (this.#closing)
+            return this.#closing;
         this.#lifetime.abort();
-        this.#changed();
-        await Promise.allSettled([...this.#tasks]);
+        this.#closing = finishCleanup([
+            () => this.#changed(),
+            async () => {
+                while (this.#tasks.size)
+                    await Promise.allSettled([...this.#tasks]);
+            },
+        ]);
+        return this.#closing;
     }
 }

package/lib/datasource/test.js

@@ -1,10 +1,11 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
+import { registerMarivoTool } from "../tool-lifecycle.js";
 import { resolveMarivoDatasourceBridge } from "./bridge.js";
 export const MARIVO_DATASOURCE_TEST_TOOL_NAME = 'marivo_datasource_test';
 export function createMarivoDatasourceTestTool(source, service) {
     return defineTool({
         name: MARIVO_DATASOURCE_TEST_TOOL_NAME,
-        description: 'Test a Marivo datasource through Host credentials. Missing credentials wait for the Web form while this call remains alive; configured connection failures return directly.',
+        description: 'Test a Marivo datasource through Host credentials after datasource changes, credential rotation, connection failures, or explicit user requests. Normal analysis with configured credentials needs no preliminary test; successful marivo_datasource_configure already tested that configuration. Missing credentials wait for the Web form only while this call remains alive; configured connection failures return directly. Only status=ok proves this connection test succeeded; verify the requested table and read access separately.',
         parameters: {
             name: { type: 'string', required: true, description: 'Configured datasource name.' },
         },
@@ -20,7 +21,7 @@ export function createMarivoDatasourceTestTool(source, service) {
     });
 }
 export function registerMarivoDatasourceTestTool(ctx, source, service) {
-    return ctx.tools.register(createMarivoDatasourceTestTool(source, service));
+    return registerMarivoTool(ctx, createMarivoDatasourceTestTool(source, service));
 }
 /** Preserve the datasource tools' public status family; raw Marivo results stay inside the service. */
 export function datasourceToolValue(result) {