@ximatai/muyun-web-app 0.26.14 → 0.26.16

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

@@ -0,0 +1,346 @@
+import type { TextPresentation } from './index';
+/** Published workflow facts shared by static and metadata driven modules. */
+export interface WorkflowDefinition {
+    id: string;
+    version: number;
+    alias: string;
+    title?: string;
+    definitionStatus: string;
+    currentVersionNo?: number;
+    approvalEnabled: boolean;
+    organizationId?: string;
+    matchExpression?: string;
+    matchPriority?: number;
+    defaultDefinition?: boolean;
+}
+export interface WorkflowVersion {
+    id: string;
+    version: number;
+    versionNo: number;
+    publishStatus: string;
+}
+export interface WorkflowNode {
+    nodeTitleText?: TextPresentation;
+    id?: string;
+    version?: number;
+    nodeKey: string;
+    title?: string;
+    nodeTitle?: string;
+    nodeType: string;
+    nodeStatus?: string;
+    approvalMode?: string;
+    approvalRatio?: number;
+    participantPolicyText?: string;
+    milestoneType?: string;
+    routeMode?: string;
+    selectorNodeKey?: string;
+    convergeNodeKey?: string;
+    convergeMode?: string;
+    convergeRatio?: number;
+    requireManualSelectionReason?: boolean;
+    allowReject?: boolean;
+    autoApproveSameUser?: boolean;
+    requireRejectReason?: boolean;
+    allowRejectReturnToMe?: boolean;
+    allowRollback?: boolean;
+    requireRollbackReason?: boolean;
+    allowAddSign?: boolean;
+    warningDurationMinutes?: number;
+    overtimeDurationMinutes?: number;
+    taskDefinitionId?: string;
+    nodeConfigText?: string;
+}
+export interface WorkflowRoute {
+    id?: string;
+    routeKey: string;
+    sourceNodeKey: string;
+    targetNodeKey: string;
+    title?: string;
+    conditionExpression?: string;
+    defaultRoute?: boolean;
+    routeStatus?: string;
+    routeReason?: string;
+    selectedReason?: string;
+}
+export interface WorkflowAddSignExplanation {
+    dimension: 'NODE' | 'ROUTE';
+    nodeKey?: string;
+    nodeStatus?: string;
+    routeKey?: string;
+    routeSourceNodeKey?: string;
+    routeTargetNodeKey?: string;
+    addSignSourceNodeKey: string;
+}
+export interface WorkflowDesign {
+    nodes: WorkflowNode[];
+    links: WorkflowRoute[];
+    layoutJson?: string;
+}
+export interface WorkflowInstance {
+    id: string;
+    moduleAlias: string;
+    recordId: string;
+    definitionTitle?: string;
+    versionNo?: number;
+    instanceStatus: string;
+    approvalStatus?: string;
+    currentNodeKeys?: string;
+    startedAt?: string;
+    startedBy?: string;
+    completedAt?: string;
+    semanticJson?: string;
+    layoutJson?: string;
+}
+export interface WorkflowTask {
+    id: string;
+    nodeInstanceId?: string;
+    nodeKey?: string;
+    taskKind: string;
+    taskStatus: string;
+    assigneeId?: string;
+    assigneeTitle?: string;
+    originalAssigneeTitle?: string;
+    actualProcessUserTitle?: string;
+    processedByDelegation?: boolean;
+    originalAssigneeId?: string;
+    actualProcessorId?: string;
+    assignmentKind?: string;
+    decision?: string;
+    completedAt?: string;
+}
+export interface WorkflowEvent {
+    messageText?: TextPresentation;
+    id: string;
+    taskId?: string;
+    eventType: string;
+    actionCode?: string;
+    nodeKey?: string;
+    operatorId?: string;
+    operatorTitle?: string;
+    reason?: string;
+    message?: string;
+    nodeInstanceId?: string;
+    occurredAt?: string;
+    eventText?: string;
+    payloadText?: string;
+}
+export interface WorkflowAction {
+    actionCode: string;
+    title: string;
+    taskId?: string;
+    nodeKey?: string;
+    nodeTitle?: string;
+    reasonRequired: boolean;
+    targetAssigneeRequired?: boolean;
+    rejectReturnToMeSupported?: boolean;
+    rejectResubmitModes?: string[];
+    defaultRejectResubmitMode?: string;
+}
+export interface WorkflowStatus {
+    canSubmit?: boolean;
+    displayStatus: string;
+    instanceId?: string;
+    errorMessage?: string;
+    errorMessageText?: TextPresentation;
+    definition?: {
+        definitionTitle?: string;
+        definitionAlias?: string;
+    };
+}
+export interface WorkflowRenderBundle {
+    instance: WorkflowInstance;
+    nodes: WorkflowNode[];
+    routes: WorkflowRoute[];
+    semanticJson?: string;
+    layoutJson?: string;
+}
+export interface WorkflowSubmitPreview extends WorkflowRenderBundle {
+    definition?: WorkflowStatus['definition'];
+    tasks: WorkflowTask[];
+    taskViews?: WorkflowTask[];
+}
+export interface WorkflowBranch {
+    branchNodeKey: string;
+    branchTitle?: string;
+    selectionPending?: boolean;
+    selectorNodeKey?: string;
+    requireManualSelectionReason?: boolean;
+    candidates: Array<{
+        routeKey: string;
+        targetNodeKey: string;
+        routeStatus: string;
+        title?: string;
+        targetNodeTitle?: string;
+        defaultRoute?: boolean;
+        conditionMatched?: boolean;
+        recommended?: boolean;
+    }>;
+}
+export interface WorkflowWorkbenchCard {
+    nodeTitleText?: TextPresentation;
+    business?: {
+        title?: string;
+        moduleTitle?: string;
+        readable: boolean;
+        moduleTitleSource?: import('./index').TextReference;
+        moduleTitleText?: import('./index').TextPresentation;
+    };
+    instanceId: string;
+    moduleAlias: string;
+    recordId: string;
+    taskId?: string;
+    nodeTitle?: string;
+    taskStatus?: string;
+    approvalStatus?: string;
+    instanceStatus: string;
+    currentAssigneeTitles: string[];
+    submitterUserTitle?: string;
+    originalAssigneeTitle?: string;
+    assignmentKind?: string;
+    delegatedToUserTitle?: string;
+    overtimeStatus?: string;
+    startedAt?: string;
+    receivedAt?: string;
+    completedAt?: string;
+}
+export interface WorkflowHistoryInstance {
+    moduleAlias: string;
+    recordId: string;
+    startedByTitle?: string;
+    id: string;
+    versionNo: number;
+    instanceStatus: string;
+    approvalStatus: string;
+    startedAt?: string;
+    archivedAt?: string;
+    lastActionReason?: string;
+}
+export interface WorkflowWorkbenchFilters {
+    moduleAlias?: string;
+    submitterUserId?: string;
+    overtimeStatus?: string;
+    instanceStatus?: string;
+    taskStatus?: string;
+    receivedFrom?: string;
+    receivedTo?: string;
+    completedFrom?: string;
+    completedTo?: string;
+}
+export interface WorkflowTaskPreparation {
+    evaluation: {
+        passed: boolean;
+        failureMessage?: string;
+        failureCheckKey?: string;
+        failureMessageText?: TextPresentation;
+        /** Frozen configuration declarations remain available even when a check currently passes. */
+        checkTexts?: Array<{
+            checkKey: string;
+            title?: string;
+            titleText?: TextPresentation;
+            failureMessage?: string;
+            failureMessageText?: TextPresentation;
+        }>;
+        checkResults: Array<{
+            checkKey: string;
+            checkTitle?: string;
+            checkTitleText?: TextPresentation;
+            passed: boolean;
+            failureMessage?: string;
+            failureMessageText?: TextPresentation;
+        }>;
+        guides: Array<{
+            guideKey: string;
+            title?: string;
+            titleText?: TextPresentation;
+            instructionText?: TextPresentation;
+            guideKind: string;
+            guideConfigText?: string;
+            targetModuleAlias?: string;
+            targetActionCode?: string;
+        }>;
+    };
+}
+export interface WorkflowConfigurationCatalog {
+    tasks: {
+        id: string;
+        title: string;
+    }[];
+    queries: {
+        id: string;
+        title: string;
+    }[];
+    generations: {
+        id: string;
+        title: string;
+        targetModuleAlias: string;
+    }[];
+    associations: {
+        id: string;
+        title: string;
+    }[];
+}
+export interface WorkflowDefinitionSelection {
+    version: number;
+    title: string;
+    organizationId: string | null;
+    matchExpression: string | null;
+    matchPriority: number;
+    defaultDefinition: boolean;
+}
+export interface WorkflowDefinitionCreate extends Omit<WorkflowDefinitionSelection, 'version'> {
+    alias: string;
+    approvalEnabled: boolean;
+    enabled: boolean;
+}
+export interface WorkflowAdminInstance {
+    instanceId: string;
+    moduleAlias: string;
+    recordId: string;
+    versionNo: number;
+    instanceStatus: string;
+    approvalStatus: string;
+    startedByTitle?: string;
+    activeNodeTitles: string[];
+    workflowVersionId?: string;
+    activeNodeLabels?: {
+        nodeKey: string;
+        title: string;
+        addedByAddSign: boolean;
+        titleText?: TextPresentation;
+    }[];
+    currentAssigneeTitles: string[];
+    overtimeStatus?: string;
+}
+export interface WorkflowAdminTask {
+    taskId: string;
+    nodeKey?: string;
+    nodeInstanceId?: string;
+    workflowVersionId?: string;
+    nodeTitleText?: TextPresentation;
+    nodeTitle: string;
+    assigneeTitle?: string;
+    taskKind: string;
+    canForceApprove: boolean;
+}
+export interface WorkflowAdminInstanceQuery {
+    moduleAlias?: string;
+    recordId?: string;
+    starterId?: string;
+    instanceStatus?: string;
+    approvalStatus?: string;
+    currentAssigneeId?: string;
+    overtimeStatus?: string;
+    page: {
+        pageNum: number;
+        pageSize: number;
+    };
+}
+export interface WorkflowAdminHistoryQuery {
+    moduleAlias?: string;
+    recordId?: string;
+    startedBy?: string;
+    page: {
+        pageNum: number;
+        pageSize: number;
+    };
+}

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

@@ -1,7 +1,10 @@
+import type { TextReference } from '../web-contracts/index';
 import { webDataChangeTypes, type WebActionResultEnvelope, type WebDataChange } from '../web-contracts/index';
 export interface ResolvedWebActionResult {
     message: string;
     messageCode?: string;
+    messageArgs?: Record<string, unknown>;
+    messageSource?: TextReference;
     messageType?: string;
     resultType?: string;
     changeSetId?: string;

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

@@ -0,0 +1,22 @@
+import type { AssistantCapabilityResult } from '../web-contracts/index';
+import type { AssistantCapability } from './assistantSurface';
+export declare const ASSISTANT_CAPABILITY_LOAD_CODE = "assistant.load-capabilities";
+export declare const ASSISTANT_CAPABILITY_SELECTION_LIMIT = 8;
+/** Discovery changes request context only. The live registry still owns execution and permission. */
+export declare function assistantCapabilityCatalog(capabilities: AssistantCapability[]): {
+    discovery: AssistantCapability<string[], unknown>;
+    project(results?: AssistantCapabilityResult[], selectedCodes?: string[], recoveryCodes?: string[]): {
+        descriptors: import("../web-contracts/index").AssistantCapabilityDescriptor[];
+        index: undefined;
+        selectedCodes: never[];
+        endDecisionAfter: string[];
+    } | {
+        endDecisionAfter: string[];
+        selectedCodes: string[];
+        descriptors: import("../web-contracts/index").AssistantCapabilityDescriptor[];
+        index: {
+            code: string;
+            description: string;
+        }[];
+    };
+};

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

@@ -0,0 +1,12 @@
+/** Model observation only; preparation still validates against the full authoritative catalog. */
+export declare function pageAssistantCatalog<T>(records: readonly T[], offset?: number, budget?: number): {
+    items: T[];
+    page: {
+        note?: string | undefined;
+        offset: number;
+        total: number;
+        nextOffset: number | null;
+        coverage: string;
+        oversizedIndexes: number[];
+    };
+};

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

@@ -0,0 +1,24 @@
+import { type LanguageContext } from './language';
+import type { OperationReceiptReference, OperationPresentation } from '../web-contracts/index';
+import { type OperationProposal, type OperationConfirmation } from './operationConfirmation';
+export { OperationRejectedError as AssistantOperationRejectedError } from './operationConfirmation';
+export type { OperationConfirmationState as AssistantConfirmationState } from './operationConfirmation';
+/** Assistant-only explanation and continuation decorate a platform command. */
+export interface AssistantOperationProposal extends OperationProposal {
+    modelSummary?: string;
+    continuation?: {
+        message: string;
+        readOnly?: boolean;
+        isCurrent(): boolean;
+    };
+}
+export interface AssistantOperationConfirmation extends OperationConfirmation {
+    readonly modelSummary: string;
+    readonly receiptReference?: OperationReceiptReference;
+    readonly continuationReadOnly?: boolean;
+    readonly continuationIsCurrent?: () => boolean;
+    takeContinuation(): string | undefined;
+}
+export declare function createAssistantOperationConfirmation(proposal: AssistantOperationProposal, scopeIsCurrent: () => boolean, now?: () => number, language?: LanguageContext): AssistantOperationConfirmation;
+/** Recovered results have no execute path, expiry renewal, or automatic continuation. */
+export declare function restoreAssistantOperationReceipt(reference: OperationReceiptReference, lookup: () => Promise<OperationPresentation | undefined>, scopeIsCurrent: () => boolean, language?: LanguageContext): AssistantOperationConfirmation;

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

@@ -0,0 +1,50 @@
+import type { OperationReceiptReference, OperationPresentation } from '../web-contracts/index';
+import type { HttpClient } from './http';
+import type { AssistantConversationMessage } from '../web-contracts/index';
+/** Display-only CODE text; never model history, command inputs or proof of execution. */
+export type AssistantControlText = {
+    source: import('../web-contracts/index').TextReference;
+    args?: Record<string, string | number | boolean | null | AssistantControlText>;
+} | {
+    parts: Array<string | AssistantControlText>;
+};
+export interface AssistantConfigurationTask {
+    goal: string;
+    mode: 'conversation' | 'visual';
+}
+export interface AssistantConversationContent {
+    configurationTask?: AssistantConfigurationTask;
+    /** Scope of model history, not conversation ownership or permission. */
+    executionScopeKey?: string;
+    title: string;
+    messages: Array<{
+        role: 'user' | 'assistant' | 'status';
+        text: string;
+        controlText?: AssistantControlText;
+        operationReceipt?: {
+            reference: OperationReceiptReference;
+            executionScopeKey: string;
+        };
+    }>;
+    history: AssistantConversationMessage[];
+    planId?: string;
+    pendingRequest?: string;
+}
+export interface AssistantConversationSnapshot {
+    id: string;
+    revision: number;
+    updatedAt: string;
+    content: AssistantConversationContent;
+}
+export interface AssistantConversationSummary {
+    id: string;
+    title: string;
+    updatedAt: string;
+}
+export interface AssistantConversationClient {
+    lookupOperation?(reference: OperationReceiptReference): Promise<OperationPresentation | undefined>;
+    list(scopeKey: string, page: number): Promise<AssistantConversationSummary[]>;
+    read(id: string, scopeKey: string): Promise<AssistantConversationSnapshot>;
+    save(id: string, scopeKey: string, expectedRevision: number, content: AssistantConversationContent): Promise<AssistantConversationSnapshot>;
+}
+export declare function createAssistantConversationClient(http: HttpClient): AssistantConversationClient;

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

@@ -1,13 +1,35 @@
+import type { AssistantModelRequestObservation } from './assistantTurnClient';
+import type { AssistantOperationConfirmation } from './assistantConfirmation';
 import type { AssistantCapabilityResult, AssistantConversationMessage, AssistantSelectionResponse, AssistantTurnOutput } from '../web-contracts/index';
-import { type AssistantSurfaceRegistry } from './assistantSurface';
+import { type AssistantInvocationToken, type AssistantCapabilitySelection, type AssistantExecutionPolicy, type AssistantSurfaceRegistry } from './assistantSurface';
+/** Shared transport limits: newest dialogue and display observations fit the existing history contract. */
+export declare function boundedAssistantConversationHistory(history: AssistantConversationMessage[]): AssistantConversationMessage[];
+/** Ephemeral, display-only evidence within the existing conversation budget. Never archived or executable. */
+export declare function createAssistantDisplayObservations(): {
+    clear: () => void;
+    forScope: (token: AssistantInvocationToken | undefined) => {
+        role: "status";
+        text: string;
+    }[];
+    record(token: AssistantInvocationToken, observation: {
+        pageInstanceKey: string;
+        text: string;
+    }): void;
+};
+export type AssistantDisplayObservations = ReturnType<typeof createAssistantDisplayObservations>;
 export interface AssistantRuntimeStepResult {
     output: AssistantTurnOutput;
+    confirmations?: AssistantOperationConfirmation[];
     results: AssistantCapabilityResult[];
     contextChanged: boolean;
     /** Successful capability invocations that committed an effect through applyEffect in this step. */
     appliedEffectCount: number;
 }
 export interface AssistantConversationOptions {
+    /** Bounded schema names owned by the current conversation, never persisted or replayed. */
+    capabilitySelection?: AssistantCapabilitySelection;
+    displayObservations?: AssistantDisplayObservations;
+    executionPolicy?: AssistantExecutionPolicy;
     signal?: AbortSignal;
     maxSteps?: number;
     /** Completed dialogue before the current user message. */
@@ -15,6 +37,8 @@ export interface AssistantConversationOptions {
     /** Structured answer to a selection shown by the immediately preceding assistant message. */
     selectionResponse?: AssistantSelectionResponse;
     onStep?(step: AssistantRuntimeStepResult): void | Promise<void>;
+    /** A validated navigation crossed execution scopes; previous model observations were discarded. */
+    onExecutionScopeChange?(): void;
     onTextDelta?(text: string, stepIndex: number): void;
     onTextDiscard?(stepIndex: number): void;
     onActivity?(phase: AssistantActivityPhase, stepIndex: number): void;
@@ -24,13 +48,23 @@ export interface AssistantConversationOptions {
 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 = {
+export type AssistantRuntimeDiagnosticEvent = ({
+    type: 'model.request.completed';
+    phase: 'work' | 'summary';
+    stepIndex: number;
+} & AssistantModelRequestObservation) | {
+    type: 'capability.elapsed';
+    stepIndex: number;
+    capabilityCode: string;
+    durationMs: number;
+} | {
     type: 'decision.started';
     stepIndex: number;
     surface: AssistantDiagnosticSurface;
     backgroundContextRefreshed: boolean;
 } | {
     type: 'decision.completed';
+    usage?: AssistantTurnOutput['usage'];
     stepIndex: number;
     finishReason?: AssistantDiagnosticFinishReason;
     toolCallCount: number;
@@ -39,17 +73,28 @@ export type AssistantRuntimeDiagnosticEvent = {
     type: 'decision.restarted';
     stepIndex: number;
     attempt: number;
-    reason: 'background-context-refresh' | 'formal-surface-ready';
+    reason: 'background-context-refresh' | 'formal-surface-ready' | 'undeclared-tool';
 } | {
     type: 'decision.failed';
     stepIndex: number;
-    reason: 'context-changed' | 'cancelled' | 'surface-settlement-failed' | 'model-request-failed';
+    reason: 'context-changed' | 'cancelled' | 'surface-unavailable' | 'surface-settlement-failed' | 'model-request-failed';
 } | {
     type: 'capability.completed';
     stepIndex: number;
     capabilityCode: string;
     outcome: 'succeeded' | 'failed' | 'replayed';
     pageEffectApplied: boolean;
+} | {
+    type: 'budget.progress';
+    stepIndex: number;
+    newObservations: number;
+    appliedEffects: number;
+    extended: boolean;
+} | {
+    type: 'summary.completed';
+    usage?: AssistantTurnOutput['usage'];
+    succeeded: boolean;
+    reason?: 'truncated' | 'undeclared-tool' | 'provider-rejected' | 'invalid-summary' | 'request-failed';
 } | {
     type: 'conversation.completed';
     stepCount: number;
@@ -57,11 +102,12 @@ export type AssistantRuntimeDiagnosticEvent = {
 };
 export interface AssistantConversationResult {
     steps: AssistantRuntimeStepResult[];
-    completed: boolean;
+    termination: 'stopped' | 'waiting-for-user' | 'repeated-call' | 'step-limit';
 }
-export declare class AssistantConversationFollowUpError extends Error {
+export declare class AssistantConversationInterruptedError extends Error {
     readonly steps: readonly AssistantRuntimeStepResult[];
-    constructor(steps: readonly AssistantRuntimeStepResult[], cause: unknown);
+    readonly termination: 'cancelled' | 'context-changed' | 'execution-interrupted' | 'model-failed';
+    constructor(steps: readonly AssistantRuntimeStepResult[], cause: unknown, termination?: 'cancelled' | 'context-changed' | 'execution-interrupted' | 'model-failed');
 }
 /**
  * Runs the bounded tool loop for one user message. Every step takes a fresh