@sim-design/training 1.0.0 → 1.1.0

package/dist-types/client/src/services/AICommandHandler.d.ts

@@ -0,0 +1,68 @@
+/**
+ * AI指令处理器
+ * 统一处理AI返回的所有指令类型
+ */
+import type { AICommand, AICommandType } from '../types/ai-commands';
+/**
+ * 指令处理器函数类型
+ */
+type CommandHandler<T = any> = (command: T) => void | Promise<void>;
+/**
+ * AI指令处理器类
+ */
+export declare class AICommandHandler {
+    private handlers;
+    private errorHandler?;
+    constructor();
+    /**
+     * 注册指令处理器
+     */
+    register<T extends AICommand>(commandType: AICommandType, handler: CommandHandler<T>): void;
+    /**
+     * 注销指令处理器
+     */
+    unregister(commandType: AICommandType): void;
+    /**
+     * 设置错误处理器
+     */
+    setErrorHandler(handler: (error: Error, command: AICommand) => void): void;
+    /**
+     * 处理单个AI指令
+     */
+    handle(command: AICommand): Promise<void>;
+    /**
+     * 处理多个AI指令（按优先级排序）
+     */
+    handleMultiple(commands: AICommand[]): Promise<void>;
+    /**
+     * 解析AI响应并处理指令
+     */
+    parseAndHandle(aiResponse: string): Promise<void>;
+    /**
+     * 错误处理
+     */
+    private handleError;
+    /**
+     * 清除所有处理器
+     */
+    clear(): void;
+}
+/**
+ * 创建全局单例
+ */
+export declare const aiCommandHandler: AICommandHandler;
+/**
+ * 插件级 AI 回复路由辅助函数
+ *
+ * - type === expectedType → 返回 { command, cleanContent }
+ * - type 存在但不匹配 → 路由到全局 aiCommandHandler，返回 { command: null, cleanContent }
+ * - 数组 → 分离本插件指令和其他指令
+ * - 解析失败 → 返回 { command: null, cleanContent }（调用方判断为纯文本）
+ *
+ * @returns { command: 匹配的指令对象或null, cleanContent: 清理后的内容 }
+ */
+export declare function parseAIResponseForPlugin<T extends AICommand>(content: string, expectedType: AICommandType): {
+    command: T | null;
+    cleanContent: string;
+};
+export {};

package/dist-types/client/src/services/cozeApiClient.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 可识别的扣子超时错误。
+ * 调用方可用 `instanceof CozeTimeoutError`（或 `err.name === 'CozeTimeoutError'`）区分「超时」与「平台错误」。
+ */
+export declare class CozeTimeoutError extends Error {
+    readonly timeoutMs: number;
+    readonly isCozeTimeout = true;
+    constructor(timeoutMs: number);
+}
+/** 注册（或用 null 清除）模块级 token 失效自愈回调。详见 ambientTokenInvalidHandler 说明。 */
+export declare const setTokenInvalidHandler: (handler: (() => Promise<string | null | undefined>) | null) => void;
+export interface StreamUpdateCallback {
+    (content: string, isComplete: boolean, eventType: string): void;
+}
+export interface SuggestionCallback {
+    (content: string, content_type: string): void;
+}
+export interface FetchCozeOptions {
+    botId: string;
+    prompt: string;
+    token: string;
+    conversationId?: string;
+    onStreamUpdate?: StreamUpdateCallback;
+    autoSaveHistory?: boolean;
+    onSuggestionUpdate?: SuggestionCallback;
+    /** 空闲超时（ms）：流在该时间内无任何新事件即中止并抛 CozeTimeoutError。默认 30000；耗时较长的生成类调用可调大。 */
+    idleTimeoutMs?: number;
+    /**
+     * token 被平台判定失效（4101）时回调：应清除旧缓存并返回一个全新的 token；
+     * 返回空值（null/undefined/空串）则不重试。不提供则遇 4101 直接抛出（保持原行为）。
+     */
+    onTokenInvalid?: () => Promise<string | null | undefined>;
+    /** @internal token 失效自愈的重试标记，防止无限重试，调用方请勿手动设置。 */
+    __tokenRetried?: boolean;
+}
+export interface FetchCozeResult {
+    response: string;
+    conversationId: string;
+}
+export declare const startHeartbeat: (botId: string, token: string, intervalMs?: number) => void;
+export declare const stopHeartbeat: () => void;
+export declare function getBotInfo(bot_id: string): Promise<import("@coze/api").BotInfo | undefined>;
+export declare const fetchCozeData: (options: FetchCozeOptions) => Promise<FetchCozeResult>;
+export declare const uploadFile: (file: File, cozeToken: string) => Promise<import("@coze/api").FileObject>;

package/dist-types/client/src/services/mockApi.d.ts

@@ -0,0 +1,48 @@
+import type { TrainingModel, EvaluationReport } from '@shared/types/index.js';
+/**
+ * Mock API 服务
+ * 提供训练模型数据，无需后端依赖
+ */
+export declare const mockApi: {
+    /**
+     * 获取实训模型
+     */
+    getTrainingModel: (modelId: string) => Promise<TrainingModel>;
+    /**
+     * 获取插件代码
+     * 注意：实际实现中，插件是本地组件，不需要动态加载代码
+     * 这个方法保留用于未来可能的动态插件加载
+     */
+    getPluginCode: (pluginId: string) => Promise<string>;
+    /**
+     * 模拟评估步骤
+     * 简单的规则评估，用于测试
+     */
+    evaluateStep: (stepId: string, studentData: any, evaluationRules: any) => Promise<EvaluationReport>;
+    /**
+     * 保存学生操作数据（模拟）
+     */
+    saveStudentOperation: (data: {
+        sessionId: string;
+        stepId: string;
+        operationData: any;
+    }) => Promise<{
+        success: boolean;
+    }>;
+    /**
+     * 保存评估结果（模拟）
+     */
+    saveEvaluation: (data: {
+        sessionId: string;
+        stepId: string;
+        evaluation: EvaluationReport;
+    }) => Promise<{
+        success: boolean;
+    }>;
+    /**
+     * 初始化会话（模拟）
+     */
+    initSession: (studentId: string, modelId: string) => Promise<{
+        sessionId: string;
+    }>;
+};

package/dist-types/client/src/services/storageService.d.ts

@@ -0,0 +1,88 @@
+/**
+ * localStorage持久化服务
+ * 管理训练会话数据的保存、加载和清理
+ */
+import type { EvaluationReport } from '@shared/types/index.js';
+/**
+ * 存储的会话数据结构
+ */
+export interface StoredSessionData {
+    studentId: string;
+    modelId: string;
+    currentStageIndex: number;
+    currentStepIndex: number;
+    studentData: Record<string, any>;
+    operationLog: any[];
+    evaluationHistory: EvaluationReport[];
+    stageAssessmentHistory?: any[];
+    startTime: string;
+    lastUpdateTime: string;
+}
+/**
+ * 存储的完整数据结构
+ */
+export interface StoredTrainingData {
+    sessions: {
+        [sessionId: string]: StoredSessionData;
+    };
+}
+/**
+ * localStorage持久化服务
+ */
+export declare class StorageService {
+    /**
+     * 获取所有存储的数据
+     */
+    private getStoredData;
+    /**
+     * 保存所有数据
+     */
+    private setStoredData;
+    /**
+     * 保存会话数据
+     */
+    saveSession(sessionId: string, sessionData: Partial<StoredSessionData>): void;
+    /**
+     * 加载会话数据
+     */
+    loadSession(sessionId: string): StoredSessionData | null;
+    /**
+     * 清除指定会话
+     */
+    clearSession(sessionId: string): void;
+    /**
+     * 获取所有会话列表
+     */
+    getAllSessions(): Array<{
+        sessionId: string;
+        data: StoredSessionData;
+    }>;
+    /**
+     * 获取学生的所有会话
+     */
+    getStudentSessions(studentId: string): Array<{
+        sessionId: string;
+        data: StoredSessionData;
+    }>;
+    /**
+     * 清理过期会话
+     */
+    cleanupOldSessions(): void;
+    /**
+     * 清除所有数据
+     */
+    clearAll(): void;
+    /**
+     * 获取存储使用情况
+     */
+    getStorageInfo(): {
+        sessionCount: number;
+        estimatedSize: number;
+        oldestSession: string | null;
+        newestSession: string | null;
+    };
+}
+/**
+ * 创建全局单例
+ */
+export declare const storageService: StorageService;

package/dist-types/client/src/stores/abilityStore.d.ts

@@ -0,0 +1,33 @@
+import type { AbilityMap, AbilityNode, AbilityCategory } from '@shared/types/index.js';
+import type { StudentProfile } from './trainingStore';
+/**
+ * 能力更新项
+ */
+interface AbilityUpdate {
+    abilityId: string;
+    delta: number;
+    reason: string;
+}
+/**
+ * 能力状态接口
+ */
+interface AbilityState {
+    abilityMap: AbilityMap | null;
+    studentProfile: StudentProfile | null;
+    setAbilityMap: (map: AbilityMap | null) => void;
+    initStudentProfile: (studentId: string, abilityMap: AbilityMap) => void;
+    updateAbilityValue: (abilityId: string, delta: number, stepId: string, stepName: string, reason: string) => void;
+    batchUpdateAbilities: (updates: AbilityUpdate[], stepId: string, stepName: string) => void;
+    getAbilityValue: (abilityId: string) => number;
+    getCategoryAverage: (category: AbilityCategory) => number;
+    getStepAbilities: (stepId: string) => AbilityNode[];
+    addCompletedStep: (stepId: string) => void;
+    persistToStorage: () => void;
+    loadFromStorage: () => void;
+    reset: () => void;
+}
+/**
+ * 能力状态管理 Store
+ */
+export declare const useAbilityStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AbilityState>>;
+export {};

package/dist-types/client/src/stores/dialogueStore.d.ts

@@ -0,0 +1,30 @@
+interface DialogueMessage {
+    role: 'customer' | 'teller';
+    content: string;
+    timestamp: number;
+    emotion?: 'neutral' | 'happy' | 'confused' | 'angry';
+    feedback?: string;
+}
+interface DialogueCacheEntry {
+    messages: DialogueMessage[];
+    dialogueLog: DialogueMessage[];
+    conversationId: string | null;
+    guidanceConversationId?: string | null;
+    firedDisturbanceIds?: string[];
+    pendingDisturbanceIds?: string[];
+    currentPhaseId?: string | null;
+    phaseHistory?: string[];
+    branchResults?: Record<string, 'positive' | 'negative'>;
+    resistanceFaded?: boolean;
+}
+interface DialogueStoreState {
+    cache: Record<string, DialogueCacheEntry>;
+    saveDialogue: (stepId: string, data: DialogueCacheEntry) => void;
+    getDialogue: (stepId: string) => DialogueCacheEntry | undefined;
+    clearStep: (stepId: string) => void;
+    clearAll: () => void;
+    persistToStorage: () => void;
+    loadFromStorage: () => void;
+}
+export declare const useDialogueStore: import("zustand").UseBoundStore<import("zustand").StoreApi<DialogueStoreState>>;
+export {};

package/dist-types/client/src/stores/formRegistryStore.d.ts

@@ -0,0 +1,45 @@
+import type { FormField } from '../plugins/shared/types';
+/**
+ * 表单模板（缓存用）
+ */
+export interface CachedFormTemplate {
+    formName: string;
+    fields: FormField[];
+    mode?: 'create' | 'edit';
+}
+/**
+ * FormRegistry 状态接口
+ */
+interface FormRegistryState {
+    templates: Record<string, CachedFormTemplate>;
+    filledData: Record<string, Record<string, any>>;
+    registerTemplate: (formName: string, template: CachedFormTemplate) => void;
+    getTemplate: (formName: string) => CachedFormTemplate | undefined;
+    hasTemplate: (formName: string) => boolean;
+    saveFilledData: (formName: string, data: Record<string, any>) => void;
+    getFilledData: (formName: string) => Record<string, any> | undefined;
+    clearFilledData: () => void;
+    reset: () => void;
+    persistToStorage: () => void;
+    loadFromStorage: (sessionId: string) => void;
+}
+/**
+ * 解析文本中的模板变量引用与表达式
+ * - {路径}：字段引用，仅做路径插值
+ * - [表达式]：受限表达式语言，支持算术/逻辑/条件/数组函数
+ */
+export declare function resolveTemplateText(text: string, caseData: any, filledData?: Record<string, Record<string, any>>): string;
+/**
+ * 解析 customerData 中的变量引用
+ * 支持：
+ *   - 常量：直接返回值（如 "身份证"）
+ *   - 案例字段引用：{customerInfo.name} → 从 caseData 中取值
+ *   - 表单字段引用：{开户申请书.customerName} → 从 filledData 中取值
+ */
+export declare function resolveCustomerData(customerData: Record<string, any> | undefined, caseData: any, filledData: Record<string, Record<string, any>>): Record<string, any>;
+/**
+ * FormRegistry Store
+ * 管理表单模板缓存和已填数据，生命周期与实训会话一致
+ */
+export declare const useFormRegistryStore: import("zustand").UseBoundStore<import("zustand").StoreApi<FormRegistryState>>;
+export {};

package/dist-types/client/src/stores/guidanceStore.d.ts

@@ -0,0 +1,17 @@
+export interface GuidanceItem {
+    id: string;
+    severity: 'info' | 'warning' | 'error';
+    message: string;
+    suggestion?: string;
+    fieldName?: string;
+    timestamp: number;
+    dismissed: boolean;
+}
+interface GuidanceStore {
+    items: GuidanceItem[];
+    addGuidance(item: Omit<GuidanceItem, 'id' | 'timestamp' | 'dismissed'>): void;
+    dismissGuidance(id: string): void;
+    clearAll(): void;
+}
+export declare const useGuidanceStore: import("zustand").UseBoundStore<import("zustand").StoreApi<GuidanceStore>>;
+export {};

package/dist-types/client/src/stores/stepEvidenceStore.d.ts

@@ -0,0 +1,14 @@
+import type { EvidenceSummary } from '@shared/types/index.js';
+import type { StepEvidenceEntry } from '../plugins/shared/types';
+interface StepEvidenceStoreState {
+    cache: Record<string, StepEvidenceEntry>;
+    saveStepEvidence: (stepId: string, summary: EvidenceSummary, rawData?: any) => void;
+    getStepEvidence: (stepId: string) => StepEvidenceEntry | undefined;
+    getAllEvidence: () => StepEvidenceEntry[];
+    clearStep: (stepId: string) => void;
+    clearAll: () => void;
+    persistToStorage: () => void;
+    loadFromStorage: () => void;
+}
+export declare const useStepEvidenceStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StepEvidenceStoreState>>;
+export {};

package/dist-types/client/src/stores/strategyLabStore.d.ts

@@ -0,0 +1,46 @@
+import type { DecisionData, SimulationResult, StrategyEvaluationResult, NodeRuntimeState, NodeOutcome } from '../plugins/shared/types';
+/**
+ * 角色对话状态
+ */
+interface CharacterDialogueState {
+    messages: Array<{
+        role: 'user' | 'character';
+        content: string;
+        timestamp: number;
+    }>;
+    conversationId: string | null;
+    finalStance?: string;
+}
+/**
+ * 策略实验室缓存条目
+ */
+interface StrategyLabCacheEntry {
+    decisions: DecisionData[];
+    simulationResults: SimulationResult[];
+    evaluations: StrategyEvaluationResult[];
+    conversationId: string | null;
+    currentDecisionIndex: number;
+    iterationCount: number;
+    characterDialogues?: Record<string, CharacterDialogueState>;
+    isInCharacterDialogue?: boolean;
+    /** 已拍定/跳过节点的归档（按 nodeId）。当前节点的工作态仍在上方零散字段 */
+    nodeStates?: NodeRuntimeState[];
+    /** 当前激活的节点下标 */
+    currentNodeIndex?: number;
+    /** 各节点拍定后计算的产出（注入下一节点的前提） */
+    nodeOutcomes?: NodeOutcome[];
+}
+/**
+ * 策略实验室 Store 状态
+ */
+interface StrategyLabStoreState {
+    cache: Record<string, StrategyLabCacheEntry>;
+    saveStrategyLab: (stepId: string, data: StrategyLabCacheEntry) => void;
+    getStrategyLab: (stepId: string) => StrategyLabCacheEntry | undefined;
+    clearStep: (stepId: string) => void;
+    clearAll: () => void;
+    persistToStorage: () => void;
+    loadFromStorage: () => void;
+}
+export declare const useStrategyLabStore: import("zustand").UseBoundStore<import("zustand").StoreApi<StrategyLabStoreState>>;
+export {};

package/dist-types/client/src/stores/trainingStore.d.ts

@@ -0,0 +1,84 @@
+import type { TrainingModel, Stage, Step, EvaluationReport, StageAssessmentReport, Case, AbilityGrowthRecord } from '@shared/types/index.js';
+/**
+ * 学生能力画像
+ */
+export interface StudentProfile {
+    studentId: string;
+    abilities: Record<string, number>;
+    strengths: string[];
+    weakPoints: string[];
+    history: ProfileHistory[];
+    abilityGrowth: AbilityGrowthRecord[];
+    categoryScores: {
+        basic: number;
+        core: number;
+        comprehensive: number;
+    };
+    completedSteps: string[];
+    totalTrainingTime: number;
+}
+interface ProfileHistory {
+    timestamp: number;
+    stepId: string;
+    ability: string;
+    oldValue: number;
+    newValue: number;
+    reason: string;
+}
+/**
+ * 实训状态接口
+ */
+interface TrainingState {
+    model: TrainingModel | null;
+    loading: boolean;
+    error: string | null;
+    currentStageIndex: number;
+    currentStepIndex: number;
+    sessionId: string | null;
+    studentData: Record<string, any>;
+    operationLog: any[];
+    evaluationHistory: EvaluationReport[];
+    currentEvaluation: EvaluationReport | null;
+    stageAssessing: boolean;
+    currentStageAssessment: StageAssessmentReport | null;
+    stageAssessmentHistory: StageAssessmentReport[];
+    studentProfile: StudentProfile | null;
+    currentCase: Case | null;
+    loadModel: (modelId: string) => Promise<void>;
+    setModel: (model: TrainingModel) => void;
+    nextStep: () => void;
+    previousStep: () => void;
+    nextStage: () => void;
+    previousStage: () => void;
+    goToStep: (stageIndex: number, stepIndex: number) => void;
+    updateStudentData: (stepId: string, data: any) => void;
+    addOperationLog: (log: any) => void;
+    addEvaluation: (evaluation: EvaluationReport) => void;
+    setCurrentEvaluation: (evaluation: EvaluationReport | null) => void;
+    initSession: (studentId: string) => Promise<void>;
+    saveToStorage: () => void;
+    loadFromStorage: (sessionId: string) => boolean;
+    reset: () => void;
+    initStudentProfile: (studentId: string) => void;
+    updateStudentProfile: (updates: Record<string, number>, strengths: string[], weakPoints: string[], stepId: string, reason: string) => void;
+    setCurrentCase: (caseData: Case | null) => void;
+    setStageAssessing: (assessing: boolean) => void;
+    setStageAssessment: (report: StageAssessmentReport | null) => void;
+    addStageAssessmentToHistory: (report: StageAssessmentReport) => void;
+    getCurrentStage: () => Stage | null;
+    getCurrentStep: () => Step | null;
+    isLastStep: () => boolean;
+    isLastStage: () => boolean;
+    isFirstStep: () => boolean;
+    isFirstStage: () => boolean;
+    getProgress: () => {
+        completed: number;
+        total: number;
+        percentage: number;
+    };
+}
+/**
+ * 实训状态管理 Store
+ */
+export declare const useTrainingStore: import("zustand").UseBoundStore<import("zustand").StoreApi<TrainingState>>;
+export {};

package/dist-types/client/src/types/ai-commands.d.ts

@@ -0,0 +1,144 @@
+/**
+ * AI智能体指令类型定义
+ * AI通过返回结构化JSON指令来控制前端流程
+ */
+/**
+ * 评估指令 - 步骤完成后AI评估学生表现
+ */
+export interface EvaluationCommand {
+    type: 'evaluation';
+    data: {
+        stepId: string;
+        totalScore: number;
+        pass: boolean;
+        dimensions: Array<{
+            name: string;
+            score: number;
+            feedback: string;
+            errors?: string[];
+            suggestions?: string[];
+        }>;
+        highlights: string[];
+        improvements: string[];
+        nextStepAdvice: string;
+    };
+}
+/**
+ * 指导严重程度
+ */
+export type GuidanceSeverity = 'info' | 'warning' | 'error';
+/**
+ * 实时指导指令 - 学生操作过程中AI给出提示
+ */
+export interface GuidanceCommand {
+    type: 'guidance';
+    severity: GuidanceSeverity;
+    data: {
+        fieldName?: string;
+        message: string;
+        suggestion?: string;
+        autoCorrect?: boolean;
+        correctValue?: any;
+    };
+}
+/**
+ * 对话角色类型
+ */
+export type DialogueRole = 'customer' | 'supervisor' | 'colleague';
+/**
+ * 对话情绪
+ */
+export type DialogueEmotion = 'neutral' | 'happy' | 'confused' | 'angry';
+/**
+ * 话术质量评价
+ */
+export type TalkQuality = 'excellent' | 'good' | 'average' | 'poor';
+/**
+ * 对话指令 - AI陪练场景中AI扮演角色对话
+ */
+export interface DialogueCommand {
+    type: 'dialogue';
+    data: {
+        role: DialogueRole;
+        content: string;
+        emotion?: DialogueEmotion;
+        talkQuality?: TalkQuality;
+        feedback?: string;
+    };
+}
+/**
+ * 案例难度
+ */
+export type CaseDifficulty = 'easy' | 'medium' | 'hard';
+/**
+ * 案例生成指令 - 动态生成新的实训案例
+ */
+export interface CaseGenerationCommand {
+    type: 'case_generation';
+    data: {
+        caseId: string;
+        caseType: string;
+        difficulty: CaseDifficulty;
+        scenario: string;
+        customerInfo: any;
+        businessData: any;
+        stepAnswers?: Record<string, any>;
+        riskPoints?: string[];
+    };
+}
+/**
+ * 能力画像更新指令 - 根据学生表现更新能力画像
+ */
+export interface ProfileUpdateCommand {
+    type: 'profile_update';
+    data: {
+        studentId: string;
+        updates: {
+            [abilityName: string]: number;
+        };
+        weakPoints: string[];
+        strengths: string[];
+    };
+}
+/**
+ * 提示词策略
+ */
+export type PromptStrategy = 'detailed' | 'concise' | 'encouraging' | 'strict';
+/**
+ * 提示词优化指令 - AI根据上下文优化后续提示词策略
+ */
+export interface PromptOptimizationCommand {
+    type: 'prompt_optimization';
+    data: {
+        nextPromptStrategy: PromptStrategy;
+        reason: string;
+        adjustments: {
+            increaseHints?: boolean;
+            decreaseHints?: boolean;
+            focusAreas?: string[];
+        };
+    };
+}
+/**
+ * AI指令联合类型
+ */
+export type AICommand = EvaluationCommand | GuidanceCommand | DialogueCommand | CaseGenerationCommand | ProfileUpdateCommand | PromptOptimizationCommand;
+/**
+ * 指令类型字符串
+ */
+export type AICommandType = AICommand['type'];
+/**
+ * 指令优先级配置
+ */
+export declare const COMMAND_PRIORITY: Record<AICommandType, number>;
+/**
+ * 指令验证结果
+ */
+export interface CommandValidationResult {
+    valid: boolean;
+    error?: string;
+}
+/**
+ * 验证AI指令格式
+ */
+export declare function validateAICommand(command: any): CommandValidationResult;

package/dist-types/client/src/types.d.ts

@@ -0,0 +1,17 @@
+import { FormField } from './plugins/shared/types';
+export interface FormTemplate {
+    formName: string;
+    mode: 'create' | 'edit';
+    fields?: FormField[];
+}
+export interface TrainingStep {
+    stepName: string;
+    initData?: any;
+}
+export interface TrainingStage {
+    steps: TrainingStep[];
+}
+export interface TrainingModel {
+    stages: TrainingStage[];
+}
+export type { FormField };