@xpert-ai/plugin-live-dashboard 0.3.0 → 0.4.0

package/dist/lib/monitor.d.ts

@@ -0,0 +1,70 @@
+import { z } from 'zod/v3';
+import { type AgentMiddleware, type IAgentMiddlewareStrategy, type IAgentMiddlewareContext } from '@xpert-ai/plugin-sdk';
+import type { TAgentMiddlewareMeta, XpertResolvedViewHostContext } from '@xpert-ai/contracts';
+import { DashboardService } from './dashboard.service';
+declare const freshnessRuleSchema: z.ZodObject<{
+    bindingId: z.ZodString;
+    fieldId: z.ZodString;
+    maxAgeSeconds: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    bindingId: string;
+    fieldId: string;
+    maxAgeSeconds: number;
+}, {
+    bindingId: string;
+    fieldId: string;
+    maxAgeSeconds: number;
+}>;
+type FreshnessRule = z.infer<typeof freshnessRuleSchema>;
+export declare class DashboardMonitor {
+    private readonly dashboards;
+    constructor(dashboards: DashboardService);
+    inspect(context: XpertResolvedViewHostContext, artifactId: string, freshnessRule?: FreshnessRule): Promise<{
+        artifactId: string;
+        versionId: string;
+        title: string;
+        status: "attention" | "healthy";
+        checkedAt: string;
+        failures: {
+            bindingId: string;
+            datasetId: string;
+            reason: "unavailable";
+        }[];
+        datasets: {
+            datasetId: string;
+            queryFetchedAt: string;
+            truncated: boolean;
+            returnedRows: number;
+        }[];
+        businessFreshness: {
+            status: "unknown" | "stale" | "fresh";
+            latestTimestamp: string | null;
+            coverage: "latest_returned_timestamp";
+            bindingId: string;
+            fieldId: string;
+            maxAgeSeconds: number;
+        } | "not_asserted";
+        availableFreshnessFields: {
+            bindingId: string;
+            fieldId: string;
+            label: string;
+        }[];
+    }>;
+}
+export declare class DashboardMonitorMiddleware implements IAgentMiddlewareStrategy {
+    private readonly monitor;
+    private readonly dashboards;
+    readonly meta: TAgentMiddlewareMeta;
+    constructor(monitor: DashboardMonitor, dashboards: DashboardService);
+    createMiddleware(options: unknown, context: IAgentMiddlewareContext): AgentMiddleware;
+}
+/** Business freshness must be an explicit data contract, never the query fetch timestamp. */
+export declare function assessFreshness(manifest: import('./dashboard.schema').DashboardManifest, datasets: import('@xpert-ai/contracts').AnalyticalDataset[], input: FreshnessRule, now: number): {
+    status: "unknown" | "stale" | "fresh";
+    latestTimestamp: string | null;
+    coverage: "latest_returned_timestamp";
+    bindingId: string;
+    fieldId: string;
+    maxAgeSeconds: number;
+};
+export {};

package/dist/lib/monitor.js

@@ -0,0 +1,101 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardMonitorMiddleware = exports.DashboardMonitor = void 0;
+exports.assessFreshness = assessFreshness;
+const common_1 = require("@nestjs/common");
+const tools_1 = require("@langchain/core/tools");
+const v3_1 = require("zod/v3");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const dashboard_service_1 = require("./dashboard.service");
+const runtime_context_1 = require("./runtime-context");
+const dashboard_icon_1 = require("./dashboard-icon");
+const freshnessRuleSchema = v3_1.z.object({ bindingId: v3_1.z.string().min(1), fieldId: v3_1.z.string().min(1), maxAgeSeconds: v3_1.z.number().int().min(1).max(31536000) }).strict();
+let DashboardMonitor = class DashboardMonitor {
+    constructor(dashboards) {
+        this.dashboards = dashboards;
+    }
+    async inspect(context, artifactId, freshnessRule) {
+        const access = await this.dashboards.access(context);
+        if (!access.project || access.archived)
+            throw new common_1.ForbiddenException('DASHBOARD_ACTIVE_PROJECT_REQUIRED');
+        const saved = await this.dashboards.open(context, artifactId, undefined, undefined, 'published');
+        if (!saved.versionId)
+            throw new Error('DASHBOARD_NOT_PUBLISHED');
+        const result = await this.dashboards.query(context, artifactId, saved.versionId, {});
+        // Reauthorize the target after the queries; a receipt is bound to this formal version.
+        const current = await this.dashboards.open(context, artifactId, undefined, undefined, 'published');
+        if (current.versionId !== saved.versionId || (await this.dashboards.access(context)).archived)
+            throw new Error('DASHBOARD_INSPECTION_CHANGED');
+        const freshness = freshnessRule ? assessFreshness(saved.manifest, result.datasets, freshnessRule, Date.now()) : undefined;
+        return { artifactId, versionId: saved.versionId, title: saved.manifest.title,
+            status: result.failures.length || freshness && freshness.status !== 'fresh' ? 'attention' : 'healthy',
+            checkedAt: new Date().toISOString(), failures: result.failures,
+            datasets: result.datasets.map(dataset => ({ datasetId: dataset.datasetId, queryFetchedAt: dataset.freshness.sourceFetchedAt,
+                truncated: dataset.completeness.truncated, returnedRows: dataset.completeness.returnedRows })),
+            businessFreshness: freshness ?? 'not_asserted',
+            availableFreshnessFields: saved.manifest.bindings.flatMap(binding => binding.output.fields.filter(field => field.logicalType === 'timestamp')
+                .map(field => ({ bindingId: binding.id, fieldId: field.id, label: field.label }))) };
+    }
+};
+exports.DashboardMonitor = DashboardMonitor;
+exports.DashboardMonitor = DashboardMonitor = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [dashboard_service_1.DashboardService])
+], DashboardMonitor);
+let DashboardMonitorMiddleware = class DashboardMonitorMiddleware {
+    constructor(monitor, dashboards) {
+        this.monitor = monitor;
+        this.dashboards = dashboards;
+        this.meta = { name: 'LiveDashboardMonitor', icon: dashboard_icon_1.dashboardIcon, features: ['live_dashboard.monitor'],
+            label: { en_US: 'Dashboard inspection', zh_Hans: '看板巡检' },
+            description: { en_US: 'Inspect published Project dashboards without editing or publishing.', zh_Hans: '检查项目正式看板，不修改或发布。' },
+            configSchema: { type: 'object', properties: {}, additionalProperties: false } };
+    }
+    createMiddleware(options, context) {
+        v3_1.z.object({}).strict().parse(options ?? {});
+        const scope = (0, runtime_context_1.dashboardRuntimeContext)(context);
+        return { name: 'LiveDashboardMonitor', tools: [
+                (0, tools_1.tool)(async ({ artifactId, freshness }) => JSON.stringify(await this.monitor.inspect(scope, artifactId, freshness)), {
+                    name: 'dashboard_inspect', description: 'Check one explicitly selected published Project dashboard as the current run actor. Returns compact binding availability and query timestamps, never data rows. Does not modify or publish. Query time is not proof of business-data freshness. Only an explicitly configured freshness rule checks the latest returned declared timestamp, and incomplete results remain unknown. Scheduled runs retain this receipt in platform execution history.',
+                    schema: v3_1.z.object({ artifactId: v3_1.z.string().uuid(), freshness: freshnessRuleSchema.optional() }).strict(), verboseParsingErrors: true,
+                    metadata: { toolName: { en_US: 'Inspect published dashboard', zh_Hans: '巡检正式看板' } }
+                }),
+                (0, tools_1.tool)(async ({ page }) => {
+                    const access = await this.dashboards.access(scope);
+                    if (!access.project || access.archived)
+                        throw new common_1.ForbiddenException('DASHBOARD_ACTIVE_PROJECT_REQUIRED');
+                    const result = await this.dashboards.listPage(scope, page, 50);
+                    return JSON.stringify({ ...result, items: result.items.filter(item => !!item.versionId).map(({ artifactId, versionId, versionNumber, title }) => ({ artifactId, versionId, versionNumber, title })) });
+                }, { name: 'dashboard_list_published', description: 'List published dashboards in the current Project. Follow hasMore/page; never infer the target from recency.',
+                    schema: v3_1.z.object({ page: v3_1.z.number().int().positive().default(1) }).strict(), verboseParsingErrors: true,
+                    metadata: { toolName: { en_US: 'List published dashboards', zh_Hans: '列出正式看板' } } })
+            ] };
+    }
+};
+exports.DashboardMonitorMiddleware = DashboardMonitorMiddleware;
+exports.DashboardMonitorMiddleware = DashboardMonitorMiddleware = __decorate([
+    (0, plugin_sdk_1.AgentMiddlewareStrategy)('LiveDashboardMonitor'),
+    __metadata("design:paramtypes", [DashboardMonitor, dashboard_service_1.DashboardService])
+], DashboardMonitorMiddleware);
+/** Business freshness must be an explicit data contract, never the query fetch timestamp. */
+function assessFreshness(manifest, datasets, input, now) {
+    const rule = freshnessRuleSchema.parse(input);
+    const binding = manifest.bindings.find(binding => binding.id === rule.bindingId);
+    const field = binding?.output.fields.find(field => field.id === rule.fieldId && field.logicalType === 'timestamp');
+    const dataset = datasets.find(dataset => dataset.datasetId === binding?.output.datasetId);
+    const values = dataset?.rows.map(row => row[rule.fieldId]) ?? [];
+    const times = values.map(value => typeof value === 'string' && /(?:Z|[+-]\d{2}:\d{2})$/.test(value) ? Date.parse(value) : NaN);
+    const unknown = !field || !dataset || dataset.completeness.truncated || !times.length || times.some(time => !Number.isFinite(time) || time > now + 60000);
+    const latest = unknown ? null : times.reduce((latest, time) => Math.max(latest, time), -Infinity);
+    return { ...rule, status: unknown ? 'unknown' : now - latest > rule.maxAgeSeconds * 1000 ? 'stale' : 'fresh',
+        latestTimestamp: latest === null ? null : new Date(latest).toISOString(), coverage: 'latest_returned_timestamp' };
+}

package/dist/lib/plugin.js

@@ -7,7 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LiveDashboardPlugin = void 0;
+const projects_service_1 = require("./projects.service");
 const content_capability_1 = require("./content-capability");
+const monitor_1 = require("./monitor");
 const content_provider_1 = require("./content.provider");
 const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
 const dashboard_service_1 = require("./dashboard.service");
@@ -16,9 +18,11 @@ const middleware_1 = require("./middleware");
 const html_validation_1 = require("./html-validation");
 const presentation_provider_1 = require("./presentation.provider");
 const sharing_service_1 = require("./sharing.service");
+const artifact_type_provider_1 = require("./artifact-type.provider");
+const provider_options_controller_1 = require("./provider-options.controller");
 let LiveDashboardPlugin = class LiveDashboardPlugin {
 };
 exports.LiveDashboardPlugin = LiveDashboardPlugin;
 exports.LiveDashboardPlugin = LiveDashboardPlugin = __decorate([
-    (0, plugin_sdk_1.XpertServerPlugin)({ providers: [content_capability_1.DashboardCapability, content_provider_1.DashboardContentProvider, content_provider_1.DashboardContentEditor, dashboard_service_1.DashboardService, view_provider_1.DashboardViewProvider, middleware_1.DashboardMiddleware, html_validation_1.HtmlDashboardValidation, presentation_provider_1.DashboardPresentationProvider, sharing_service_1.DashboardSharingService] })
+    (0, plugin_sdk_1.XpertServerPlugin)({ controllers: [provider_options_controller_1.DashboardProviderOptionsController], providers: [projects_service_1.DashboardProjectsService, monitor_1.DashboardMonitor, monitor_1.DashboardMonitorMiddleware, artifact_type_provider_1.DashboardArtifactType, content_capability_1.DashboardCapability, content_provider_1.DashboardContentProvider, content_provider_1.DashboardContentEditor, dashboard_service_1.DashboardService, view_provider_1.DashboardViewProvider, middleware_1.DashboardMiddleware, html_validation_1.HtmlDashboardValidation, presentation_provider_1.DashboardPresentationProvider, sharing_service_1.DashboardSharingService] })
 ], LiveDashboardPlugin);

package/dist/lib/project.d.ts

@@ -0,0 +1,106 @@
+export declare const DASHBOARD_PROJECT_TYPE: {
+    readonly applicationKey: "@xpert-ai/plugin-live-dashboard:live-dashboard";
+    readonly projectTypeKey: "dashboard";
+};
+export declare const dashboardApp: {
+    type: "app";
+    name: string;
+    icon: {
+        type: "svg";
+        alt: string;
+        value: string;
+    };
+    appConfig: {
+        scope: "organization";
+        assistantTemplateKey: string;
+        workspace: {
+            mode: "dedicated";
+            sharing: "private";
+            name: {
+                en_US: string;
+                zh_Hans: string;
+            };
+            description: {
+                en_US: string;
+                zh_Hans: string;
+            };
+        };
+        knowledgebases: never[];
+        modelRequirements: {
+            primary: true;
+        };
+        presentation: {
+            developer: string;
+            tagline: {
+                en_US: string;
+                zh_Hans: string;
+            };
+            longDescription: {
+                en_US: string;
+                zh_Hans: string;
+            };
+            screenshots: string[];
+            features: {
+                key: string;
+                title: {
+                    en_US: string;
+                    zh_Hans: string;
+                };
+                description: {
+                    en_US: string;
+                    zh_Hans: string;
+                };
+            }[];
+            useCases: {
+                en_US: string;
+                zh_Hans: string;
+            }[];
+            dataScope: {
+                en_US: string;
+                zh_Hans: string;
+            };
+            initializationSummary: {
+                en_US: string;
+                zh_Hans: string;
+            };
+            initializationSteps: {
+                en_US: string;
+                zh_Hans: string;
+            }[];
+        };
+        entry: {
+            type: "assistant-chat";
+        };
+    };
+    displayName: {
+        en_US: string;
+        zh_Hans: string;
+    };
+    description: {
+        en_US: string;
+        zh_Hans: string;
+    };
+    projectTypes: {
+        key: "dashboard";
+        title: {
+            en_US: string;
+            zh_Hans: string;
+        };
+        icon: {
+            type: "svg";
+            alt: string;
+            value: string;
+        };
+        binding: {
+            kind: "project";
+        };
+    }[];
+};
+export type DashboardAccess = {
+    project: boolean;
+    archived: boolean;
+    canReadDraft: boolean;
+    canEdit: boolean;
+    canManage: boolean;
+};
+export type DashboardMode = 'published' | 'draft';

package/dist/lib/project.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardApp = exports.DASHBOARD_PROJECT_TYPE = void 0;
+const dashboard_icon_1 = require("./dashboard-icon");
+const app_config_1 = require("./app-config");
+exports.DASHBOARD_PROJECT_TYPE = {
+    applicationKey: '@xpert-ai/plugin-live-dashboard:live-dashboard', projectTypeKey: 'dashboard'
+};
+exports.dashboardApp = {
+    type: 'app', name: 'live-dashboard', icon: dashboard_icon_1.dashboardIcon,
+    appConfig: app_config_1.dashboardAppConfig,
+    displayName: { en_US: 'Live Dashboard', zh_Hans: '实时看板' },
+    description: { en_US: 'Create and use live dashboards in Assistant ChatKit with a synchronized Project selection.', zh_Hans: '在助理 ChatKit 中按项目制作和使用实时看板，项目选择双向同步。' },
+    projectTypes: [{ key: exports.DASHBOARD_PROJECT_TYPE.projectTypeKey,
+            title: { en_US: 'Live Dashboard project', zh_Hans: '实时看板项目' }, icon: dashboard_icon_1.dashboardIcon,
+            binding: { kind: 'project' } }]
+};

package/dist/lib/projects.schema.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod/v3';
+export declare const projectSearchSchema: z.ZodObject<{
+    search: z.ZodDefault<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+}, "strict", z.ZodTypeAny, {
+    search: string;
+    page: number;
+}, {
+    search?: string | undefined;
+    page?: number | undefined;
+}>;
+export declare const dashboardProjectSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+}, {
+    id: string;
+    name: string;
+}>;
+export declare const dashboardProjectsSchema: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name: string;
+    }, {
+        id: string;
+        name: string;
+    }>, "many">;
+    page: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    page: number;
+    items: {
+        id: string;
+        name: string;
+    }[];
+    hasMore: boolean;
+}, {
+    page: number;
+    items: {
+        id: string;
+        name: string;
+    }[];
+    hasMore: boolean;
+}>;

package/dist/lib/projects.schema.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardProjectsSchema = exports.dashboardProjectSchema = exports.projectSearchSchema = void 0;
+const v3_1 = require("zod/v3");
+exports.projectSearchSchema = v3_1.z.object({ search: v3_1.z.string().trim().max(200).default(''), page: v3_1.z.number().int().positive().default(1) }).strict();
+exports.dashboardProjectSchema = v3_1.z.object({ id: v3_1.z.string().uuid(), name: v3_1.z.string() });
+exports.dashboardProjectsSchema = v3_1.z.object({ items: v3_1.z.array(exports.dashboardProjectSchema), page: v3_1.z.number().int().positive(), hasMore: v3_1.z.boolean() });

package/dist/lib/projects.service.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod/v3';
+import type { XpertResolvedViewHostContext } from '@xpert-ai/contracts';
+import { type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
+import { projectSearchSchema } from './projects.schema';
+export { projectSearchSchema } from './projects.schema';
+/** Selection uses the host's membership and Assistant binding policy, never a client-supplied data scope. */
+export declare class DashboardProjectsService {
+    private readonly runtime;
+    constructor(runtime: RuntimeCapabilityRegistry);
+    private actor;
+    current(context: XpertResolvedViewHostContext): Promise<{
+        id: string;
+        name: string;
+    } | null>;
+    list(context: XpertResolvedViewHostContext, input: z.infer<typeof projectSearchSchema>): Promise<{
+        items: {
+            id: string;
+            name: string;
+        }[];
+        page: number;
+        hasMore: boolean;
+    }>;
+}

package/dist/lib/projects.service.js

@@ -0,0 +1,65 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardProjectsService = exports.projectSearchSchema = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+const dashboard_service_1 = require("./dashboard.service");
+var projects_schema_1 = require("./projects.schema");
+Object.defineProperty(exports, "projectSearchSchema", { enumerable: true, get: function () { return projects_schema_1.projectSearchSchema; } });
+/** Selection uses the host's membership and Assistant binding policy, never a client-supplied data scope. */
+let DashboardProjectsService = class DashboardProjectsService {
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    actor(context) {
+        if (context.hostType !== 'agent' || !context.tenantId || !context.organizationId || !context.userId)
+            throw new common_1.ForbiddenException('DASHBOARD_ACCESS_DENIED');
+        return { tenantId: context.tenantId, organizationId: context.organizationId, userId: context.userId };
+    }
+    async current(context) {
+        const id = (0, dashboard_service_1.projectId)(context);
+        if (!id)
+            return null;
+        const access = await this.runtime.require(plugin_sdk_1.ProjectAccessRuntimeCapability).assertAssistant({ actor: this.actor(context), projectId: id, assistantId: context.hostId });
+        return { id, name: access.name ?? id };
+    }
+    async list(context, input) {
+        const actor = this.actor(context), access = this.runtime.require(plugin_sdk_1.ProjectAccessRuntimeCapability);
+        const projects = await access.listReadable({ actor });
+        const items = [];
+        for (const project of projects) {
+            if (project.archived || !(project.name ?? project.projectId).toLocaleLowerCase().includes(input.search.toLocaleLowerCase()))
+                continue;
+            try {
+                await access.assertAssistant({ actor, projectId: project.projectId, assistantId: context.hostId });
+            }
+            catch (error) {
+                if (error instanceof common_1.ForbiddenException)
+                    continue;
+                throw error;
+            }
+            items.push({ id: project.projectId, name: project.name ?? project.projectId });
+        }
+        items.sort((a, b) => a.name.localeCompare(b.name) || a.id.localeCompare(b.id));
+        const start = (input.page - 1) * 20;
+        return { items: items.slice(start, start + 20), page: input.page, hasMore: start + 20 < items.length };
+    }
+};
+exports.DashboardProjectsService = DashboardProjectsService;
+exports.DashboardProjectsService = DashboardProjectsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)(plugin_sdk_1.XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], DashboardProjectsService);

package/dist/lib/prompt-workflows.d.ts

@@ -1,3 +1,4 @@
-import type { SkillSlashCommand } from '@xpert-ai/contracts';
-/** Commands are resolved from the installed middleware, including on existing Assistants. */
+import type { SkillSlashCommand, TPromptWorkflow } from '@xpert-ai/contracts';
 export declare const dashboardPromptWorkflows: SkillSlashCommand[];
+/** Separate names keep the host's middleware-first merge from hiding these editable shortcuts. */
+export declare const dashboardWorkspacePrompts: TPromptWorkflow[];

package/dist/lib/prompt-workflows.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dashboardPromptWorkflows = void 0;
+exports.dashboardWorkspacePrompts = exports.dashboardPromptWorkflows = void 0;
 const dashboard_icon_1 = require("./dashboard-icon");
 const context = `Work in the current authorized Assistant/project scope. Use the user's language for the page and response. Read the installed live-dashboard skill through read_skill_file and follow the references relevant to this task. Respect provider policy, access controls and tool schemas. Never change deployment, credentials, Assistant configuration or business-source data.
 Resolve source/provider pairs, Artifact IDs, fields and file paths from current tools, not names or previous conversation claims. Use only real query results; no invented business data, targets, thresholds, comparison periods or activity feeds. Keep queries read-only and bounded. Report actual tool failures and diagnosticId when supplied. A missing capability or runtime binding is a blocker, not permission to bypass validation or switch presentation modes.`;
@@ -30,7 +30,7 @@ function command(prompt) {
     };
 }
 /** Commands are resolved from the installed middleware, including on existing Assistants. */
-exports.dashboardPromptWorkflows = [
+const prompts = [
     {
         name: 'dashboard-standard-auto', group: 'standard',
         label: { en_US: 'Standard · Choose a business theme', zh_Hans: '标准看板 · 自动选题新建' },
@@ -115,4 +115,18 @@ exports.dashboardPromptWorkflows = [
         argsHint: '目标看板、筛选场景、预期业务结果（可选）',
         instructions: ['Acceptance only. Resolve the exact requested Artifact, open its current saved state with dashboard_open and record its identity/revision. Do not modify files, call save tools, publish or change source data. Preview its saved Bindings with actual defaults and observed alternative filter values; use dashboard_test_filter to validate affected queries and the null/all case. For HTML inspect its saved lifecycle and dependency contract as well. If actual viewer controls can be exercised through available authorized tools, check initial load, apply filters, refresh and reopening. Otherwise mark viewer behavior untested and give at most three manual actions with observable expected results. Do not equate a successful query or resource card with a verified browser interaction.']
     }
-].map(command);
+];
+exports.dashboardPromptWorkflows = prompts.map(command);
+/** Separate names keep the host's middleware-first merge from hiding these editable shortcuts. */
+exports.dashboardWorkspacePrompts = prompts.map((prompt) => ({
+    name: `live-${prompt.name}`,
+    label: prompt.label.zh_Hans,
+    description: prompt.description.zh_Hans,
+    icon: dashboard_icon_1.dashboardIcon,
+    category: 'live-dashboard',
+    argsHint: prompt.argsHint,
+    template: [context, ...prompt.instructions, 'User requirements / 用户需求：', '{{args}}'].join('\n\n'),
+    actionType: 'insert_text',
+    tags: ['live-dashboard', prompt.group],
+    visibility: 'team'
+}));

package/dist/lib/provider-options.controller.d.ts

@@ -0,0 +1,10 @@
+import { type RuntimeCapabilityRegistry } from '@xpert-ai/plugin-sdk';
+export declare class DashboardProviderOptionsController {
+    private readonly runtime;
+    constructor(runtime: RuntimeCapabilityRegistry);
+    list(): Promise<{
+        value: string;
+        label: string;
+        description: string;
+    }[]>;
+}

package/dist/lib/provider-options.controller.js

@@ -0,0 +1,49 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DashboardProviderOptionsController = void 0;
+const common_1 = require("@nestjs/common");
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+let DashboardProviderOptionsController = class DashboardProviderOptionsController {
+    constructor(runtime) {
+        this.runtime = runtime;
+    }
+    async list() {
+        const tenantId = plugin_sdk_1.RequestContext.currentTenantId();
+        const organizationId = plugin_sdk_1.RequestContext.getOrganizationId();
+        const userId = plugin_sdk_1.RequestContext.currentUserId();
+        if (!tenantId || !organizationId || !userId)
+            throw new common_1.UnauthorizedException();
+        // The host revalidates the actor and filters source access; never accept scope from query parameters.
+        const sources = await this.runtime.require(plugin_sdk_1.AnalyticsRuntimeCapability).list({ tenantId, organizationId, userId });
+        const options = new Map();
+        for (const source of sources)
+            for (const provider of source.providers) {
+                options.set(provider.id, { value: provider.id, label: provider.name, description: provider.id });
+            }
+        return [...options.values()].sort((left, right) => left.value.localeCompare(right.value));
+    }
+};
+exports.DashboardProviderOptionsController = DashboardProviderOptionsController;
+__decorate([
+    (0, common_1.Get)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], DashboardProviderOptionsController.prototype, "list", null);
+exports.DashboardProviderOptionsController = DashboardProviderOptionsController = __decorate([
+    (0, common_1.Controller)('live-dashboard/provider-options'),
+    __param(0, (0, common_1.Inject)(plugin_sdk_1.XPERT_RUNTIME_CAPABILITIES_TOKEN)),
+    __metadata("design:paramtypes", [Object])
+], DashboardProviderOptionsController);

package/dist/lib/resource-card.js

@@ -16,7 +16,7 @@ function dashboardResourceCard(scope, saved) {
         icon: { type: dashboard_icon_1.dashboardIcon.type, value: dashboard_icon_1.dashboardIcon.value },
         open: {
             ...(0, dashboard_navigation_1.dashboardNavigationTarget)(scope), selectionId: saved.artifactId,
-            ...(saved.state === 'published' && saved.versionId ? { parameters: { versionId: saved.versionId } } : {})
+            parameters: saved.state === 'published' && saved.versionId ? { versionId: saved.versionId } : { mode: 'draft' }
         }
     };
 }

package/dist/lib/runtime-context.d.ts

@@ -0,0 +1,3 @@
+import type { XpertResolvedViewHostContext } from '@xpert-ai/contracts';
+import { type IAgentMiddlewareContext } from '@xpert-ai/plugin-sdk';
+export declare function dashboardRuntimeContext(context: IAgentMiddlewareContext): XpertResolvedViewHostContext;

package/dist/lib/runtime-context.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dashboardRuntimeContext = dashboardRuntimeContext;
+const plugin_sdk_1 = require("@xpert-ai/plugin-sdk");
+function dashboardRuntimeContext(context) {
+    if (!context.xpertId)
+        throw new Error('DASHBOARD_ASSISTANT_REQUIRED');
+    return { tenantId: context.tenantId ?? plugin_sdk_1.RequestContext.currentTenantId(),
+        organizationId: context.organizationId ?? plugin_sdk_1.RequestContext.getOrganizationId(), userId: context.userId ?? plugin_sdk_1.RequestContext.currentUserId(),
+        hostType: 'agent', hostId: context.xpertId, slots: [],
+        ...(context.projectId ? { runtimeScope: { projectId: context.projectId, conversationId: context.conversationId ?? null,
+                dataScopeKey: `project:${context.projectId}`, workspaceFiles: { catalog: 'projects', scopeId: context.projectId, projectId: context.projectId } } } : {}) };
+}

package/dist/lib/save-evidence.d.ts

@@ -15,7 +15,7 @@ export declare function dashboardSaveEvidence(files: () => WorkspaceFilesApi): {
         token: number;
         generations: Map<string, number>;
         supersedesPaths: string[];
-        confirmation: "draft" | "source";
+        confirmation: "source" | "draft";
     };
     accept(save: SaveAttempt, output: unknown): Promise<void>;
     readonly pending: boolean;

package/dist/lib/templates.d.ts

@@ -0,0 +1,2 @@
+import type { XpertTemplateContribution } from '@xpert-ai/plugin-sdk';
+export declare const dashboardTemplates: XpertTemplateContribution[];