@ximatai/muyun-web-app 0.26.13 → 0.26.14

package/dist/types/views/metadataGovernanceAssistantSurface.d.ts

@@ -0,0 +1,122 @@
+import { type AssistantCapability, type AssistantSurface, type AssistantTurnRequester } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+import type { MetadataChangeSetPreview } from './metadataModelChangeSetClient';
+export interface MetadataGovernanceAssistantModelSummary {
+    moduleAlias: string;
+    moduleTitle?: string;
+    relationCount: number;
+    selectedRelation?: {
+        relationId: string;
+        title?: string;
+        fieldCount: number;
+        fields: Array<{
+            fieldName: string;
+            title?: string;
+            fieldSpecAlias?: string;
+            propertyKind: string;
+            governance: string;
+        }>;
+        truncated: boolean;
+    };
+    draft: {
+        active: boolean;
+        dirty: boolean;
+        editorOpen: boolean;
+    };
+    fieldSpecs: Array<{
+        alias: string;
+        title?: string;
+    }>;
+}
+export interface AddMetadataFieldDraftInput {
+    title: string;
+    fieldName?: string;
+    fieldSpecAlias: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    sortable?: boolean;
+    titleField?: boolean;
+}
+export interface UpdateMetadataFieldDraftInput {
+    fieldName: string;
+    title?: string;
+    fieldSpecAlias?: string;
+    required?: boolean;
+    unique?: boolean;
+    indexed?: boolean;
+    sortable?: boolean;
+    titleField?: boolean;
+    enabled?: boolean;
+}
+export type MetadataPropertyFieldKind = 'MODULE_REFERENCE' | 'DICTIONARY';
+export interface FindMetadataFieldTargetsInput {
+    kind: MetadataPropertyFieldKind;
+    keyword?: string;
+}
+export interface AddMetadataPropertyFieldDraftInput {
+    kind: MetadataPropertyFieldKind;
+    title: string;
+    fieldName?: string;
+    target: string;
+    selectionMode?: 'SINGLE' | 'MULTIPLE';
+    required?: boolean;
+}
+export interface PreparedMetadataPropertyFieldDraft {
+    relationId: string;
+    kind: MetadataPropertyFieldKind;
+    title: string;
+    fieldName: string;
+    columnName: string;
+    fieldSpecAlias: string;
+    required: boolean;
+    reference?: {
+        targetModuleAlias: string;
+        targetMetadataId?: string;
+        targetKeyField: string;
+        targetLabelField: string;
+    };
+    dictionary?: {
+        applicationAlias: string;
+        categoryAlias: string;
+        selectionMode: 'SINGLE' | 'MULTIPLE';
+    };
+}
+export interface MetadataGovernanceAssistantAdapter {
+    summary(): MetadataGovernanceAssistantModelSummary;
+    proposal(): MetadataModelChangeSetProposal | undefined;
+    preview(proposal: MetadataModelChangeSetProposal, signal: AbortSignal): Promise<MetadataChangeSetPreview>;
+    fieldSpecAliases(): string[];
+    editableBasicFieldNames(): string[];
+    addFieldDraft?(input: AddMetadataFieldDraftInput): {
+        relationId: string;
+        fieldName: string;
+        columnName: string;
+        title: string;
+        fieldSpecAlias: string;
+    };
+    updateFieldDraft?(input: UpdateMetadataFieldDraftInput): {
+        relationId: string;
+        fieldName: string;
+        title?: string;
+        fieldSpecAlias?: string;
+    };
+    findFieldTargets?(input: FindMetadataFieldTargetsInput, signal: AbortSignal): Promise<{
+        targets: Array<{
+            target: string;
+            title?: string;
+        }>;
+        truncated: boolean;
+    }>;
+    preparePropertyFieldDraft?(input: AddMetadataPropertyFieldDraftInput, signal: AbortSignal): Promise<PreparedMetadataPropertyFieldDraft>;
+    commitPropertyFieldDraft?(prepared: PreparedMetadataPropertyFieldDraft): {
+        relationId: string;
+        kind: MetadataPropertyFieldKind;
+        fieldName: string;
+        columnName: string;
+        title: string;
+        fieldSpecAlias: string;
+        target: string;
+    };
+}
+export declare function createMetadataGovernanceAssistantSurface(adapter: MetadataGovernanceAssistantAdapter, requestTurn: AssistantTurnRequester, contributedCapabilities?: () => AssistantCapability[]): AssistantSurface;

package/dist/types/views/metadataModelChangeSetClient.d.ts

@@ -0,0 +1,36 @@
+import type { HttpClient } from '../web-core/index';
+import type { MetadataModelChangeSetProposal } from './metadataModelEditSession';
+export type MetadataChangeSetIssue = {
+    severity: 'WARNING' | 'ERROR' | string;
+    code: string;
+    subject: string;
+    message: string;
+};
+export type MetadataChangeSetPreview = {
+    proposalFingerprint: string;
+    fieldImpacts: Array<{
+        operation: string;
+        fieldName: string;
+        columnName: string;
+        platformManaged: boolean;
+        description: string;
+    }>;
+    schemaImpacts: Array<{
+        operation: string;
+        schemaName: string;
+        tableName: string;
+        columnName: string;
+        description: string;
+    }>;
+    orderImpacts: Array<{
+        operation: string;
+        relationId?: string;
+        parentMetadataId?: string;
+        orderedIds: string[];
+        description: string;
+    }>;
+    warnings: MetadataChangeSetIssue[];
+    errors: MetadataChangeSetIssue[];
+};
+export declare function previewMetadataModelChangeSet(http: HttpClient, moduleAlias: string, proposal: MetadataModelChangeSetProposal, signal?: AbortSignal): Promise<MetadataChangeSetPreview>;
+export declare function applyMetadataModelChangeSet(http: HttpClient, moduleAlias: string, proposal: MetadataModelChangeSetProposal, proposalFingerprint: string): Promise<unknown>;

package/dist/types/views/metadataNaming.d.ts

@@ -1,4 +1,8 @@
 import type { MetadataFieldPropertyKind } from './metadataOrchestrationState';
+export declare const PLATFORM_FIELD_NAME_PATTERN = "^[a-z][A-Za-z0-9]{0,62}$";
+export declare const DYNAMIC_RECORD_RESERVED_FIELD_NAMES: Set<string>;
+export declare function isPlatformFieldName(value: string): boolean;
+export declare function isDynamicRecordReservedFieldName(value: string): boolean;
 export declare function physicalNameOf(fieldName?: string): string;
 export declare function generatedFieldName(title?: string): string;
 /** Default names for newly created business fields; runtime semantics remain metadata-driven. */

package/dist/types/views/runtimeLogSse.d.ts

@@ -1,13 +1,3 @@
-export interface RuntimeLogSseEvent {
-    event: string;
-    data: string;
-}
-/**
- * Incrementally decodes an SSE response body. Keeping this small parser beside
- * the log surface avoids coupling a one-way operational stream to the broader
- * realtime messaging runtime.
- */
-export declare function createRuntimeLogSseParser(emit: (event: RuntimeLogSseEvent) => void): {
-    push(chunk: string): void;
-    finish(): void;
-};
+import { createSseParser, type SseEvent } from '../web-core/index';
+export type RuntimeLogSseEvent = SseEvent;
+export declare const createRuntimeLogSseParser: typeof createSseParser;

package/dist/types/vue-ui-antdv/components/UiTextArea.vue.d.ts

@@ -19,6 +19,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     focusSelection: typeof focusSelection;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
     "update:value": (value: string) => any;
+    keydown: (event: KeyboardEvent) => any;
     drop: (event: {
         source: UiDragSource;
         selection: {
@@ -33,6 +34,7 @@ declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
     }) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
     "onUpdate:value"?: ((value: string) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
     onDrop?: ((event: {
         source: UiDragSource;
         selection: {

package/dist/types/web-contracts/assistant.d.ts

@@ -0,0 +1,59 @@
+export interface AssistantCapabilityDescriptor {
+    code: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+}
+export interface AssistantSurfaceContext {
+    surface: string;
+    title?: string;
+    facts: Record<string, unknown>;
+}
+export interface AssistantCapabilityCall {
+    id: string;
+    code: string;
+    input: unknown;
+}
+export interface AssistantCapabilityResult {
+    callId: string;
+    capabilityCode: string;
+    output?: unknown;
+    error?: {
+        code: string;
+        message: string;
+    };
+}
+export interface AssistantConversationMessage {
+    role: 'user' | 'assistant';
+    text: string;
+}
+export interface AssistantSelectionOption {
+    id: string;
+    label: string;
+}
+export interface AssistantSelectionInteraction {
+    interactionId: string;
+    prompt: string;
+    inputPolicy: 'free_text_allowed' | 'selection_required';
+    presentation: 'options' | 'confirmation';
+    options: AssistantSelectionOption[];
+}
+export interface AssistantSelectionResponse {
+    interactionId: string;
+    optionId: string;
+    label: string;
+}
+export interface AssistantTurnInput {
+    message: string;
+    history?: AssistantConversationMessage[];
+    context: AssistantSurfaceContext;
+    capabilities: AssistantCapabilityDescriptor[];
+    results?: AssistantCapabilityResult[];
+    selectionResponse?: AssistantSelectionResponse;
+}
+export interface AssistantTurnOutput {
+    text?: string;
+    toolCalls: AssistantCapabilityCall[];
+    selection?: AssistantSelectionInteraction;
+    finishReason?: string;
+    requestId?: string;
+}

package/dist/types/web-contracts/index.d.ts

@@ -1,4 +1,5 @@
 export type Primitive = string | number | boolean | null | undefined;
+export * from './assistant';
 export type OptionValue = string | number;
 export type OptionValueList = OptionValue[];
 export interface Option {

package/dist/types/web-core/assistantRuntime.d.ts

@@ -0,0 +1,77 @@
+import type { AssistantCapabilityResult, AssistantConversationMessage, AssistantSelectionResponse, AssistantTurnOutput } from '../web-contracts/index';
+import { type AssistantSurfaceRegistry } from './assistantSurface';
+export interface AssistantRuntimeStepResult {
+    output: AssistantTurnOutput;
+    results: AssistantCapabilityResult[];
+    contextChanged: boolean;
+    /** Successful capability invocations that committed an effect through applyEffect in this step. */
+    appliedEffectCount: number;
+}
+export interface AssistantConversationOptions {
+    signal?: AbortSignal;
+    maxSteps?: number;
+    /** Completed dialogue before the current user message. */
+    history?: AssistantConversationMessage[];
+    /** Structured answer to a selection shown by the immediately preceding assistant message. */
+    selectionResponse?: AssistantSelectionResponse;
+    onStep?(step: AssistantRuntimeStepResult): void | Promise<void>;
+    onTextDelta?(text: string, stepIndex: number): void;
+    onTextDiscard?(stepIndex: number): void;
+    onActivity?(phase: AssistantActivityPhase, stepIndex: number): void;
+    /** Receives content-free execution facts for local diagnostics or a governed telemetry adapter. */
+    onDiagnostic?(event: AssistantRuntimeDiagnosticEvent): void | Promise<void>;
+}
+export type AssistantActivityPhase = 'understanding' | 'executing' | 'responding';
+type AssistantDiagnosticSurface = 'workbench' | 'module-page' | 'metadata-governance' | 'other';
+type AssistantDiagnosticFinishReason = 'stop' | 'tool_calls' | 'length' | 'content_filter' | 'other';
+export type AssistantRuntimeDiagnosticEvent = {
+    type: 'decision.started';
+    stepIndex: number;
+    surface: AssistantDiagnosticSurface;
+    backgroundContextRefreshed: boolean;
+} | {
+    type: 'decision.completed';
+    stepIndex: number;
+    finishReason?: AssistantDiagnosticFinishReason;
+    toolCallCount: number;
+    hasText: boolean;
+} | {
+    type: 'decision.restarted';
+    stepIndex: number;
+    attempt: number;
+    reason: 'background-context-refresh' | 'formal-surface-ready';
+} | {
+    type: 'decision.failed';
+    stepIndex: number;
+    reason: 'context-changed' | 'cancelled' | 'surface-settlement-failed' | 'model-request-failed';
+} | {
+    type: 'capability.completed';
+    stepIndex: number;
+    capabilityCode: string;
+    outcome: 'succeeded' | 'failed' | 'replayed';
+    pageEffectApplied: boolean;
+} | {
+    type: 'conversation.completed';
+    stepCount: number;
+    bounded: boolean;
+};
+export interface AssistantConversationResult {
+    steps: AssistantRuntimeStepResult[];
+    completed: boolean;
+}
+export declare class AssistantConversationFollowUpError extends Error {
+    readonly steps: readonly AssistantRuntimeStepResult[];
+    constructor(steps: readonly AssistantRuntimeStepResult[], cause: unknown);
+}
+/**
+ * Runs the bounded tool loop for one user message. Every step takes a fresh
+ * Surface snapshot so navigation and draft changes are observed before the
+ * model decides its next action.
+ */
+export declare function runAssistantConversation(registry: AssistantSurfaceRegistry, message: string, options?: AssistantConversationOptions): Promise<AssistantConversationResult>;
+/**
+ * Executes one bounded model step. A context-changing capability ends the step;
+ * the caller starts the next turn from a fresh Surface snapshot.
+ */
+export declare function runAssistantStep(registry: AssistantSurfaceRegistry, message: string, previousResults?: AssistantCapabilityResult[], signal?: AbortSignal): Promise<AssistantRuntimeStepResult>;
+export {};

package/dist/types/web-core/assistantSurface.d.ts

@@ -0,0 +1,92 @@
+import type { AssistantCapabilityCall, AssistantCapabilityDescriptor, AssistantSurfaceContext, AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+import type { AssistantTurnProgress } from './assistantTurnClient';
+export interface AssistantCapability<TInput = unknown, TOutput = unknown> {
+    descriptor: AssistantCapabilityDescriptor;
+    parseInput(input: unknown): TInput;
+    execute(input: TInput, context: AssistantCapabilityExecutionContext): Promise<TOutput>;
+}
+export declare function emptyAssistantCapabilityInputSchema(): Record<string, unknown>;
+export declare function parseEmptyAssistantCapabilityInput(input: unknown): Record<string, never>;
+export interface AssistantCapabilityExecutionContext {
+    signal: AbortSignal;
+    /** Explicit caller cancellation; unlike signal, it is not aborted by an expected Surface replacement. */
+    cancellationSignal?: AbortSignal;
+    isCurrent(): boolean;
+    /** Commit invocation-local guarded state without claiming a user-visible page effect. */
+    commitInternalState<T>(commit: () => T): T;
+    /**
+     * Apply a page effect, retaining its execution scope while background work settles.
+     * Navigation adapters may return the token of an explicitly validated replacement surface.
+     */
+    applyEffect<T>(effect: () => T, settle?: () => Promise<void | AssistantInvocationToken>): T;
+}
+export interface AssistantSurface {
+    describe(): AssistantSurfaceContext;
+    capabilities(): AssistantCapability[];
+    requestTurn(input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
+}
+export interface AssistantSurfaceRegistration {
+    pageInstanceKey: string;
+    fallback?: boolean;
+    /**
+     * Waits for background page transitions to finish before the model receives a
+     * context snapshot. It must not wait for missing user input or mutate page state.
+     */
+    settle?(signal: AbortSignal): Promise<void>;
+    contextRevision(): string;
+    /**
+     * User-controlled execution scope. Background refreshes must leave this stable
+     * so the runtime can safely refresh context without discarding the user's goal.
+     */
+    interactionRevision?(): string;
+    surface: AssistantSurface;
+}
+export interface AssistantInvocationToken {
+    pageInstanceKey: string;
+    surfaceGeneration: number;
+    contextRevision: string;
+    interactionRevision?: string;
+    fallback: boolean;
+}
+export interface AssistantSurfaceSnapshot {
+    token: AssistantInvocationToken;
+    context: AssistantSurfaceContext;
+    capabilities: AssistantCapabilityDescriptor[];
+}
+export interface AssistantSurfaceRegistry {
+    register(registration: AssistantSurfaceRegistration): () => void;
+    activate(pageInstanceKey: string | undefined): void;
+    snapshot(): AssistantSurfaceSnapshot | undefined;
+    /** Observe registration and active-page changes; read the current snapshot when notified. */
+    subscribe(listener: () => void): () => void;
+    waitForActiveSurface(options?: {
+        pageInstanceKey?: string;
+        requireFormal?: boolean;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<AssistantSurfaceSnapshot>;
+    /** Waits for the current page to settle and returns a fresh, execution-compatible snapshot. */
+    settleActiveSurface(token: AssistantInvocationToken, signal?: AbortSignal): Promise<AssistantSurfaceSnapshot>;
+    requestTurn(input: Omit<AssistantTurnInput, 'context' | 'capabilities'>, token: AssistantInvocationToken, signal?: AbortSignal, progress?: AssistantTurnProgress): Promise<AssistantTurnOutput>;
+    invoke(call: AssistantCapabilityCall, token: AssistantInvocationToken, signal?: AbortSignal): Promise<{
+        value: unknown;
+        contextChanged: boolean;
+    }>;
+}
+export interface AssistantSurfaceHost {
+    registry: AssistantSurfaceRegistry;
+    activePageInstanceKey(): string | undefined;
+    capabilities?(): AssistantCapability[];
+}
+export declare function provideAssistantSurfaceHost(host: AssistantSurfaceHost): void;
+export declare function useAssistantSurfaceHost(): AssistantSurfaceHost | undefined;
+export declare class StaleAssistantInvocationError extends Error {
+    constructor();
+}
+/** Safe, bounded feedback that helps the model repair a rejected capability call. */
+export declare class AssistantCapabilityUsageError extends Error {
+    constructor(message: string);
+}
+export declare function createAssistantSurfaceRegistry(): AssistantSurfaceRegistry;
+/** Compares page identity and revisions, independently of object property order. */
+export declare function sameAssistantInvocationToken(left: AssistantInvocationToken | undefined, right: AssistantInvocationToken | undefined): boolean;

package/dist/types/web-core/assistantTurnClient.d.ts

@@ -0,0 +1,8 @@
+import type { AssistantTurnInput, AssistantTurnOutput } from '../web-contracts/index';
+import { type HttpClient } from './http';
+export interface AssistantTurnProgress {
+    onTextDelta?(text: string): void;
+}
+export type AssistantTurnRequester = (input: AssistantTurnInput, signal: AbortSignal, progress?: AssistantTurnProgress) => Promise<AssistantTurnOutput>;
+/** Uses the supplied transport as-is so page-owned tenant scope remains authoritative. */
+export declare function createAssistantTurnRequester(http: HttpClient): AssistantTurnRequester;

package/dist/types/web-core/index.d.ts

@@ -1,7 +1,11 @@
 export * from './errors';
 export * from './http';
+export * from './sse';
 export * from './query';
 export * from './actionResult';
+export * from './assistantSurface';
+export * from './assistantRuntime';
+export * from './assistantTurnClient';
 export * from './businessNotifications';
 export * from './dataChanges';
 export * from './realtime';

package/dist/types/web-core/sse.d.ts

@@ -0,0 +1,9 @@
+export interface SseEvent {
+    event: string;
+    data: string;
+}
+/** Incrementally decodes the SSE framing shared by authenticated platform streams. */
+export declare function createSseParser(emit: (event: SseEvent) => void): {
+    push(chunk: string): void;
+    finish(): void;
+};