@yiyi_zhang/reactflow-ui 0.4.0 → 1.0.0

package/dist/services/ai/transport.d.ts

@@ -0,0 +1,58 @@
+/**
+ * AI Transport — 传输层反转
+ *
+ * 背景：默认的 direct 模式让 API Key 直接留存在终端用户浏览器中，直连大模型服务商
+ * （参见 protocolAdapter.ts 的 streamOpenAI/streamAnthropic）。这仅适合开发调试，
+ * 生产环境应通过集成方自己的后端转发模型请求，密钥、计费、限流、审计都留在后端完成。
+ *
+ * 本文件提供两种反转方案：
+ * - `endpoint`：把统一的 AgentRequest POST 给集成方后端，后端以 SSE 帧协议回传 StreamEvent。
+ *   后端参考实现（Node/Express，约 30 行）：
+ *
+ *   ```js
+ *   app.post('/api/ai/chat', async (req, res) => {
+ *     res.setHeader('Content-Type', 'text/event-stream');
+ *     res.setHeader('Cache-Control', 'no-cache');
+ *     res.setHeader('Connection', 'keep-alive');
+ *     // req.body = { messages, tools, meta } —— 按需转发给 OpenAI/Anthropic，
+ *     // 或直接复用本仓库的 streamOpenAI/streamAnthropic 实现（Node 端可直接 import 使用）。
+ *     for await (const event of callYourLlmProvider(req.body)) {
+ *       res.write(`data: ${JSON.stringify(event)}\n\n`);
+ *     }
+ *     res.end();
+ *   });
+ *   ```
+ *
+ * - `custom`：完全自定义的流式函数，适合已有网关/SDK 的集成方直接接入。
+ *
+ * 不设置 `transport` 时，AiConfig 的 provider/apiKey/baseUrl/model 视为 direct 模式
+ * （向后兼容现状），仅建议用于开发调试或内部可信环境。
+ */
+import type { Message, ToolDef, StreamEvent } from './protocolAdapter';
+/** endpoint / custom 传输统一入参：与 direct 模式内部构造的请求体等价 */
+export interface AgentRequest {
+    messages: Message[];
+    tools: ToolDef[];
+    meta?: {
+        sessionId?: string;
+    };
+}
+export type AiTransport = {
+    type: 'endpoint';
+    /** 集成方后端代理地址，POST AgentRequest，响应为 `data: <JSON StreamEvent>\n\n` 的 SSE 流 */
+    url: string;
+    /** 附加请求头（如后端会话鉴权 Cookie/Token 之外的自定义头） */
+    headers?: Record<string, string>;
+} | {
+    type: 'custom';
+    /** 完全自定义的流式实现，直接产出统一的 StreamEvent */
+    stream: (req: AgentRequest, signal: AbortSignal) => AsyncIterable<StreamEvent>;
+};
+/**
+ * endpoint 模式：POST AgentRequest，解析 SSE 帧（`data: <JSON>\n\n`）为 StreamEvent。
+ * 帧解析逻辑与 protocolAdapter 的 OpenAI/Anthropic 流解析一致地处理跨 chunk 边界，
+ * 避免 JSON 被截断在两次 read() 之间。
+ */
+export declare function streamEndpoint(transport: Extract<AiTransport, {
+    type: 'endpoint';
+}>, req: AgentRequest, signal?: AbortSignal): AsyncGenerator<StreamEvent>;

package/dist/services/ai/workflowSynthesizer.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Workflow Synthesizer & Deep Semantic Verifier
+ *
+ * Implements the 4-phase progressive workflow generation strategy:
+ *   Phase 1 (blueprint):  init_workflow_blueprint   — Define workflow metadata, input/output contracts, timeout & resilience policy
+ *   Phase 2 (topology):   scaffold_workflow_topology — Design overall task orchestration topology & control flow (SWITCH/FORK_JOIN/DO_WHILE)
+ *   Phase 3 (configure):  configure_workflow_tasks   — Enrich individual tasks with detailed parameters, HTTP/SubWorkflow configs & data-flow wiring
+ *   Phase 4 (verify):     commit_workflow_proposal   — Holistic semantic, control-flow, and data-flow verification before committing proposal
+ */
+import type { WorkflowDef, TaskDef } from '../../types/conductor';
+import type { ValidationItem } from '../../types/workflow';
+export type SynthesisPhase = 'idle' | 'blueprint' | 'topology' | 'configure' | 'verify' | 'completed';
+export interface BlueprintArgs {
+    name: string;
+    description?: string;
+    version?: number;
+    ownerEmail?: string;
+    timeoutPolicy?: 'TIME_OUT_WF' | 'ALERT_ONLY';
+    timeoutSeconds?: number;
+    failureWorkflow?: string;
+    inputParameters?: string[];
+    outputParameters?: Record<string, any>;
+}
+export interface TopologyArgs {
+    tasks: TaskDef[];
+}
+export interface TaskConfigurationItem {
+    /** Target taskReferenceName */
+    ref: string;
+    name?: string;
+    description?: string;
+    inputParameters?: Record<string, any>;
+    httpRequest?: Record<string, any>;
+    subWorkflowParam?: {
+        name: string;
+        version?: number;
+        taskToDomain?: Record<string, string>;
+    };
+    timeoutSeconds?: number;
+    retryCount?: number;
+    retryLogic?: 'FIXED' | 'EXPONENTIAL_BACKOFF' | 'LINEAR_BACKOFF';
+    retryDelaySeconds?: number;
+    optional?: boolean;
+    caseValueParam?: string;
+    caseExpression?: string;
+    loopCondition?: string;
+    joinOn?: string[];
+    dynamicForkTasksParam?: string;
+    dynamicForkTasksInputParamName?: string;
+}
+export interface ConfigureTasksArgs {
+    configurations: TaskConfigurationItem[];
+    outputParameters?: Record<string, any>;
+    inputParameters?: string[];
+}
+export interface VerificationSummary {
+    isValid: boolean;
+    totalTasks: number;
+    configuredTasks: number;
+    dataFlowLinks: number;
+    autoFixed: string[];
+    errors: ValidationItem[];
+    warnings: ValidationItem[];
+}
+/**
+ * Collects all tasks in execution order (pre-order traversal of top-level and nested tasks).
+ */
+export declare function collectAllTasksInOrder(tasks?: TaskDef[]): TaskDef[];
+/**
+ * Normalizes a single task's structure to prevent common LLM schema mismatches:
+ * - Ensures `name` and `taskReferenceName` and `type` exist
+ * - Normalizes `HTTP` task `httpRequest` / `inputParameters.uri` into `inputParameters.http_request`
+ * - Normalizes `SUB_WORKFLOW` `workflowName` into `subWorkflowParam.name`
+ * - Normalizes `TERMINATE` `terminationStatus` into `inputParameters.terminationStatus`
+ */
+export declare function normalizeTaskDef(task: TaskDef, autoFixed?: string[]): TaskDef;
+/**
+ * Extracts all `${...}` expressions from an arbitrary JSON value.
+ */
+export declare function extractExpressions(value: any): string[];
+/**
+ * Normalizes an entire WorkflowDef:
+ * - Ensures `version: 1`, `schemaVersion: 2`, `timeoutPolicy`
+ * - Normalizes all tasks and FORK_JOIN <-> JOIN pairings
+ * - Auto-collects `${workflow.input.xxx}` into `workflow.inputParameters` if missing
+ */
+export declare function normalizeWorkflowDef(def: WorkflowDef): {
+    workflow: WorkflowDef;
+    autoFixed: string[];
+};
+/**
+ * Phase 1: Initializes the workflow blueprint (metadata + input/output contract).
+ */
+export declare function applyBlueprint(currentDraft: WorkflowDef | null, args: BlueprintArgs): WorkflowDef;
+/**
+ * Phase 2: Scaffolds the task orchestration topology on top of the blueprint.
+ */
+export declare function applyTopologyScaffold(currentDraft: WorkflowDef | null, args: TopologyArgs): {
+    workflow: WorkflowDef;
+    autoFixed: string[];
+};
+/**
+ * Phase 3: Enriches individual tasks in the working draft with detailed configurations.
+ */
+export declare function applyTaskConfigurations(currentDraft: WorkflowDef, args: ConfigureTasksArgs): {
+    workflow: WorkflowDef;
+    configuredRefs: string[];
+    missingRefs: string[];
+    autoFixed: string[];
+};
+/**
+ * Performs comprehensive verification of a workflow definition:
+ * 1. Built-in structural & task-type rules (`validateWorkflow`)
+ * 2. Data-flow reference integrity (`${taskRef.output.*}` must reference an existing upstream task)
+ * 3. Control-flow completeness (FORK_JOIN <-> JOIN joinOn validity, non-empty branches)
+ * 4. Task configuration completeness metrics
+ */
+export declare function verifyWorkflowSemantics(def: WorkflowDef, autoFixedPrior?: string[]): VerificationSummary;

package/dist/services/aiService.d.ts

@@ -1,11 +1,13 @@
 /**
  * AI Interaction Service (OpenAI Standard)
+ *
+ * @deprecated 这是 WorkflowIDE 内置 AI Copilot 的遗留实现（仅 OpenAI 协议、文本解析 diff）。
+ * 新代码请使用 `AiConfig` + `services/ai/protocolAdapter`（双协议、原生 tool-call、
+ * 传输层反转）。两套实现将在后续版本收敛为一套，详见 `docs/design/` 下的架构规划。
  */
-export interface AIServiceConfig {
-    apiKey: string;
-    baseUrl: string;
-    model: string;
-}
+import type { AiConfig } from './ai/protocolAdapter';
+/** @deprecated 使用 `AiConfig`（从 `services/ai/protocolAdapter` 或 `/ai` 入口导入）代替。保留为类型别名以避免破坏现有集成代码。 */
+export type AIServiceConfig = AiConfig;
 export interface ChatMessage {
     role: 'system' | 'user' | 'assistant';
     content: string;

package/dist/services/wlsp/workflowLsp.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Workflow Language Server (W-LSP)
+ *
+ * 提供工业级工作流静态分析、DAG 上游作用域推导、多源 Schema 自动推断、
+ * 零延迟确定性变量补全（Intellisense）、数据血缘图（DFG）构建与全图引用重构（Auto-Refactor）。
+ */
+import { WorkflowDef, TaskDef } from '../../types/conductor';
+import { TaskExecutionData } from '../../types/workflow';
+export type ValueType = 'string' | 'number' | 'boolean' | 'object' | 'array' | 'any';
+export interface InferredField {
+    /** 字段相对路径，如 "response.body.id" 或 "result" */
+    path: string;
+    /** 完整 Conductor 引用表达式，如 "${http_get.output.response.body.id}" */
+    expression: string;
+    /** 推导出的字段类型 */
+    valueType: ValueType;
+    /** 运行态真实样本值预览（若存在） */
+    sampleValue?: string;
+    /** 描述说明 */
+    description?: string;
+    /** Schema 来源 */
+    source: 'runtime_sample' | 'schema_registry' | 'task_type_contract';
+}
+export interface WlspCompletionItem {
+    /** 展示名称 */
+    label: string;
+    /** 插入的完整表达式，如 "${fetch_user.output.userId}" */
+    value: string;
+    /** 分类 */
+    category: 'upstream' | 'workflow_input' | 'variable' | 'system';
+    /** 数据类型 */
+    valueType: ValueType;
+    /** 来源任务引用名或分组名 */
+    sourceRef: string;
+    /** 来源任务显示名称 */
+    sourceLabel: string;
+    /** 详细描述 */
+    description: string;
+    /** 运行态或默认值样本预览 */
+    sampleValue?: string;
+    /** 是否来自条件分支（可能未执行） */
+    isConditional?: boolean;
+}
+export interface DataFlowEdge {
+    id: string;
+    sourceRef: string;
+    targetRef: string;
+    fieldPath: string;
+    expression: string;
+    sourceType: 'task_output' | 'workflow_variable';
+    isValidUpstream: boolean;
+    issue?: 'undefined_ref' | 'forward_ref' | 'sibling_branch_ref';
+}
+export interface DataFlowGraph {
+    edges: DataFlowEdge[];
+    diagnostics: Array<{
+        taskRef: string;
+        expression: string;
+        issue: 'undefined_ref' | 'forward_ref' | 'sibling_branch_ref';
+        message: string;
+    }>;
+}
+export interface UpstreamTaskInfo {
+    task: TaskDef;
+    /** 是否位于条件分支内部（非必经路径） */
+    isConditional: boolean;
+}
+/**
+ * 精确计算在 targetTaskRef 执行前所有合法的上游祖先节点
+ */
+export declare function getUpstreamAncestorsWithMeta(workflowDef: WorkflowDef | null | undefined, targetTaskRef: string): UpstreamTaskInfo[];
+export declare function getUpstreamAncestors(workflowDef: WorkflowDef | null | undefined, targetTaskRef: string): TaskDef[];
+/**
+ * 推导单个任务的输出 Schema 字段列表
+ */
+export declare function inferTaskOutputSchema(task: TaskDef, executionData?: Record<string, TaskExecutionData> | null): InferredField[];
+/**
+ * 为指定目标任务生成零延迟确定性上下文补全项列表
+ */
+export declare function getCompletionItems(workflowDef: WorkflowDef | null | undefined, targetTaskRef: string, executionData?: Record<string, TaskExecutionData> | null, workflowInputSample?: Record<string, any> | null): WlspCompletionItem[];
+/**
+ * 扁平化获取工作流中的所有任务列表
+ */
+export declare function getAllTasksFlat(tasks: TaskDef[] | undefined, acc?: TaskDef[]): TaskDef[];
+/**
+ * 构建全图数据血缘依赖图 (DFG) 与编译期静态数据流诊断
+ */
+export declare function buildDataFlowGraph(workflowDef: WorkflowDef | null | undefined): DataFlowGraph;
+/**
+ * 全图级联重构任务引用名 (Auto-Refactor TaskReferenceName)
+ *
+ * 当用户在属性面板修改某个节点的 taskReferenceName 时，自动扫描并更新：
+ * 1. 所有任务的 inputParameters / httpRequest / expression / loopCondition 中的 ${oldRef.xxx} 和 $.oldRef
+ * 2. 所有 JOIN 节点的 joinOn / defaultExclusiveJoinTask 列表
+ * 3. 工作流级别的 outputParameters
+ */
+export declare function refactorTaskReferenceName(workflowDef: WorkflowDef, oldRef: string, newRef: string): {
+    updatedDef: WorkflowDef;
+    replacedCount: number;
+    affectedTaskRefs: string[];
+};

package/dist/store/aiStore.d.ts

@@ -0,0 +1,230 @@
+/**
+ * AI Store — state management for AI workflow assistant
+ *
+ * Manages: conversation history, proposed workflow (for review),
+ * AI configuration, and usage metrics.
+ *
+ * Exposed as both a factory (`createAiStore`, for per-`<AiWorkflowIDE>`-instance
+ * isolation via IdeStoresContext — see store/ideStoresContext.tsx) and a default
+ * singleton (for callers outside that context, e.g. WorkflowIDE's shared canvas).
+ */
+import type { AiConfig, Message } from '../services/ai/protocolAdapter';
+import type { WorkflowDef } from '../types/conductor';
+import type { DiffSummary } from '../services/ai/toolExecutor';
+import type { SynthesisPhase, VerificationSummary } from '../services/ai/workflowSynthesizer';
+import type { WorkflowLevel } from '../types/workflowLibrary';
+export interface AiChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    /** If this message triggered a proposal, link it here */
+    proposalId?: string;
+    timestamp: number;
+}
+export interface ProposedChange {
+    id: string;
+    proposedDef: WorkflowDef;
+    diff: DiffSummary;
+    /** Inferred workflow level based on sub-workflow references */
+    inferredLevel?: WorkflowLevel;
+    /** Holistic semantic & data-flow verification summary */
+    verification?: VerificationSummary;
+    /** Message that triggered this proposal */
+    messageId: string;
+    /**
+     * JSON snapshot of the canvas workflowDef at the moment the proposal was created.
+     * Used to detect stale proposals when the user has edited the canvas during review.
+     */
+    baselineHash: string;
+}
+/**
+ * PI-style Durable Execution Checkpoint.
+ * Captures the complete state of an in-flight or interrupted multi-phase agent session
+ * so it can be resumed (`runner.resume()`) or committed (`runner.commitDraftNow()`)
+ * without re-running completed phases.
+ */
+export interface DurableSessionCheckpoint {
+    sessionId: string;
+    userPrompt: string;
+    assistantMsgId: string;
+    phase: SynthesisPhase;
+    workingDraft: WorkflowDef | null;
+    agentHistory: Message[];
+    stepIndex: number;
+    selfHealCount: number;
+    status: 'running' | 'paused' | 'failed' | 'completed';
+    lastError?: string;
+    updatedAt: number;
+}
+export interface RepairAction {
+    id: string;
+    label: string;
+    type: 'rerun_from' | 'skip' | 'retry_workflow' | 'modify_def';
+    taskRef?: string;
+    risk?: 'low' | 'medium' | 'high';
+    description?: string;
+}
+export interface RepairProposal {
+    id: string;
+    diagnosis: string;
+    actions: RepairAction[];
+    messageId: string;
+}
+export interface PlanStep {
+    step: number;
+    action: string;
+    tool?: string;
+}
+export interface PendingPlan {
+    id: string;
+    title: string;
+    steps: PlanStep[];
+    summary?: string;
+    messageId: string;
+}
+export interface AiMetrics {
+    totalProposals: number;
+    acceptedProposals: number;
+    rejectedProposals: number;
+    /** Cumulative token usage for this session (M4.4). Only incremented when the
+     *  provider reports usage — best-effort, not every provider/proxy includes it. */
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+}
+export interface ClarificationOption {
+    id: string;
+    label: string;
+    description: string;
+    icon?: string;
+}
+export interface PendingClarification {
+    id: string;
+    question: string;
+    context?: string;
+    options: ClarificationOption[];
+    messageId: string;
+}
+export interface WorkflowRecommendation {
+    workflowName: string;
+    matchReason: string;
+    matchScore: 'exact' | 'partial' | 'similar';
+}
+export interface PendingRecommendation {
+    id: string;
+    userIntent: string;
+    recommendations: WorkflowRecommendation[];
+    messageId: string;
+}
+interface AiState {
+    config: AiConfig;
+    messages: AiChatMessage[];
+    isStreaming: boolean;
+    streamingText: string;
+    chatPanelOpen: boolean;
+    /** The current pending proposal (only one at a time) */
+    pendingProposal: ProposedChange | null;
+    /** AI-generated multi-step plan awaiting user approval */
+    pendingPlan: PendingPlan | null;
+    /** AI-generated repair proposal for run-mode failures */
+    pendingRepair: RepairProposal | null;
+    metrics: AiMetrics;
+    /** Context-aware chips shown after the user accepts a proposal */
+    followUpChips: string[] | null;
+    /** Undo stack: previous WorkflowDef snapshots (max 5, oldest first) */
+    undoStack: WorkflowDef[];
+    /** Pending clarification question awaiting user selection */
+    pendingClarification: PendingClarification | null;
+    /** Pending workflow recommendation awaiting user selection */
+    pendingRecommendation: PendingRecommendation | null;
+    /**
+     * Message queued for the AI pipeline from outside AiCommandCenter
+     * (e.g. proposal acceptance, canvas node click). AiCommandCenter
+     * picks this up via useEffect and calls runner.send(), then clears it.
+     */
+    pendingAutoSend: string | null;
+    /** Current in-flight step label (e.g. "正在搜索工作流库…"), set by AgentRunner */
+    toolStatus: string;
+    /** Last message that failed to send, offered back via a retry button */
+    retryInput: string | null;
+    /**
+     * Append-only log of completed steps for the current agent turn (M2.2 AgentTimeline).
+     * Cleared at the start of each `send()`. Self-heal retries log their own entry so
+     * the correction is visible rather than silent.
+     */
+    timelineEntries: TimelineEntry[];
+    /** Current progressive workflow synthesis phase ('idle' | 'blueprint' | 'topology' | 'configure' | 'verify' | 'completed') */
+    synthesisPhase: SynthesisPhase;
+    /** In-progress workflow draft accumulated across progressive synthesis stages */
+    workingDraft: WorkflowDef | null;
+    /** PI-style durable session checkpoint for pause/resume/fault-recovery */
+    durableCheckpoint: DurableSessionCheckpoint | null;
+}
+export interface TimelineEntry {
+    id: string;
+    label: string;
+    icon: 'done' | 'warning';
+}
+interface AiActions {
+    setConfig: (config: Partial<AiConfig>) => void;
+    addMessage: (msg: Omit<AiChatMessage, 'id' | 'timestamp'>) => string;
+    updateMessage: (id: string, content: string) => void;
+    setStreaming: (isStreaming: boolean) => void;
+    setStreamingText: (text: string) => void;
+    appendStreamingText: (delta: string) => void;
+    clearMessages: () => void;
+    setChatPanelOpen: (open: boolean) => void;
+    toggleChatPanel: () => void;
+    setProposal: (proposal: Omit<ProposedChange, 'id' | 'baselineHash'>) => string;
+    clearProposal: () => void;
+    recordAccept: () => void;
+    recordReject: () => void;
+    getMetrics: () => AiMetrics;
+    /** Accumulates token usage reported by the provider for one model turn (M4.4) */
+    recordUsage: (usage: {
+        promptTokens?: number;
+        completionTokens?: number;
+    }) => void;
+    setFollowUpChips: (chips: string[]) => void;
+    clearFollowUpChips: () => void;
+    setPlan: (plan: Omit<PendingPlan, 'id'>) => string;
+    clearPlan: () => void;
+    setRepair: (repair: Omit<RepairProposal, 'id'>) => string;
+    clearRepair: () => void;
+    /** Push the given def onto the undo stack (called before applying a proposal) */
+    pushUndo: (def: WorkflowDef) => void;
+    /** Pop and return the most recent undo snapshot, or null if stack is empty */
+    popUndo: () => WorkflowDef | null;
+    clearUndo: () => void;
+    canUndo: () => boolean;
+    setClarification: (c: Omit<PendingClarification, 'id'>) => string;
+    clearClarification: () => void;
+    setRecommendation: (r: Omit<PendingRecommendation, 'id'>) => string;
+    clearRecommendation: () => void;
+    /** Queue a message to be sent through the AI pipeline by AiCommandCenter */
+    setPendingAutoSend: (msg: string | null) => void;
+    /** Restore conversation + pending proposal + optional durable checkpoint from a persisted draft (M1.4) */
+    hydrateFromDraft: (messages: AiChatMessage[], pendingProposal: ProposedChange | null, durableCheckpoint?: DurableSessionCheckpoint | null) => void;
+    setToolStatus: (status: string) => void;
+    setRetryInput: (input: string | null) => void;
+    addTimelineEntry: (label: string, icon?: 'done' | 'warning') => void;
+    clearTimeline: () => void;
+    setSynthesisStage: (phase: SynthesisPhase, draft?: WorkflowDef | null) => void;
+    saveCheckpoint: (checkpoint: DurableSessionCheckpoint | null) => void;
+    clearCheckpoint: () => void;
+}
+export type AiStore = AiState & AiActions;
+/**
+ * Creates an independent AiStore instance.
+ *
+ * @param persistKey  localStorage key for provider/baseUrl/model + metrics (never
+ *                    the apiKey or conversation itself). Pass `false` to keep this
+ *                    instance fully in-memory — no localStorage writes at all.
+ *                    Defaults to a stable shared key so existing single-instance
+ *                    integrations keep their persisted config across reloads;
+ *                    pass a unique key per instance when embedding multiple
+ *                    `<AiWorkflowIDE>` on the same page to avoid them clobbering
+ *                    each other's persisted config.
+ */
+export declare function createAiStore(persistKey?: string | false): import("zustand").UseBoundStore<import("zustand").StoreApi<AiStore>>;
+declare const useAiStore: import("zustand").UseBoundStore<import("zustand").StoreApi<AiStore>>;
+export default useAiStore;

package/dist/store/ideStoresContext.d.ts

@@ -0,0 +1,39 @@
+/**
+ * IdeStoresContext — per-`<AiWorkflowIDE>`-instance state isolation (M3.2)
+ *
+ * Before this, aiStore/libraryStore/toolRegistry were module-level singletons:
+ * two `<AiWorkflowIDE>` mounted on the same page shared one conversation, one
+ * pending proposal, one workflow library, one set of custom tools — the second
+ * instance would silently stomp the first. AiWorkflowIDE now creates a fresh
+ * set of these per mount (via createAiStore/createLibraryStore/new ToolRegistry)
+ * and provides them through this context; every AiNative component and the
+ * AgentRunner it constructs read from `useIdeStores()` instead of importing the
+ * default singletons directly.
+ *
+ * `workflowStore` (the canvas/task-graph state) is NOT part of this context yet —
+ * it remains a shared singleton because it's also consumed by WorkflowIDE's much
+ * larger component tree (nodes, panels) that this pass didn't migrate. That's a
+ * documented follow-up, not an oversight: see docs/design/双IDE组件架构审查.md §2.
+ */
+import type { ReactNode } from 'react';
+import type { UseBoundStore, StoreApi } from 'zustand';
+import type { AiStore } from './aiStore';
+import type { LibraryStore } from './libraryStore';
+import type { ToolRegistry } from '../services/ai/toolRegistry';
+export interface IdeStores {
+    aiStore: UseBoundStore<StoreApi<AiStore>>;
+    libraryStore: UseBoundStore<StoreApi<LibraryStore>>;
+    toolRegistry: ToolRegistry;
+}
+export declare function IdeStoresProvider({ stores, children }: {
+    stores: IdeStores;
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+/** Reads the per-instance stores. Throws if used outside `<AiWorkflowIDE>` — every AiNative component is always rendered under it. */
+export declare function useIdeStores(): IdeStores;
+/**
+ * Non-throwing variant for components shared with WorkflowIDE (e.g. WorkflowDesigner),
+ * which renders both under `<AiWorkflowIDE>` (provider present) and standalone under
+ * `<WorkflowIDE>` (no provider — falls back to the module singleton there instead).
+ */
+export declare function useIdeStoresOptional(): IdeStores | null;

package/dist/store/libraryStore.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Library Store — sub-workflow catalog state
+ *
+ * Kept separate from aiStore to avoid circular dependencies (aiStore imports
+ * types from toolExecutor, which used to read this store directly; since M2.1
+ * toolExecutor is pure and AgentRunner passes library items in explicitly, but
+ * the separate store is still worth keeping for its narrow, focused shape).
+ *
+ * Populated by AiWorkflowIDE when the workflowLibrary prop changes.
+ * Read by AgentRunner (search_workflow_library / system prompt catalog) via
+ * whichever instance the owning `<AiWorkflowIDE>` created — see createLibraryStore.
+ */
+import type { WorkflowLibraryItem } from '../types/workflowLibrary';
+interface LibraryState {
+    items: WorkflowLibraryItem[];
+}
+interface LibraryActions {
+    setLibrary: (items: WorkflowLibraryItem[]) => void;
+    clearLibrary: () => void;
+}
+export type LibraryStore = LibraryState & LibraryActions;
+/** Creates an independent LibraryStore instance (no persistence — populated fresh from props each mount). */
+export declare function createLibraryStore(): import("zustand").UseBoundStore<import("zustand").StoreApi<LibraryStore>>;
+declare const useLibraryStore: import("zustand").UseBoundStore<import("zustand").StoreApi<LibraryStore>>;
+export default useLibraryStore;

package/dist/types/aiEvents.d.ts

@@ -0,0 +1,40 @@
+/**
+ * AI Event types for audit logging and analytics.
+ *
+ * Pass an `onAiEvent` callback to <AiWorkflowIDE> to receive all AI lifecycle events.
+ *
+ * ```tsx
+ * <AiWorkflowIDE
+ *   onAiEvent={(event) => auditLog.record(event)}
+ * />
+ * ```
+ */
+export type AiEventType = 'proposal:created' | 'proposal:accepted' | 'proposal:accepted:partial' | 'proposal:rejected' | 'stage:completed' | 'session:resumed' | 'plan:created' | 'plan:executed' | 'plan:cancelled' | 'repair:proposed'
+/** User clicked the inline second-click confirmation before a runtime-mutating repair action fires */
+ | 'repair:confirmed' | 'repair:executed' | 'repair:dismissed' | 'tool:called' | 'undo:applied'
+/** AI request failed (network/HTTP/provider error). The user only ever sees a humanized
+ *  message — the raw diagnostic text is only available here, via `rawMessage`. */
+ | 'ai:error';
+export interface AiEvent {
+    type: AiEventType;
+    timestamp: number;
+    /** For tool:called events */
+    tool?: string;
+    /** For stage:completed events */
+    phase?: string;
+    /** For repair:executed / repair:confirmed events */
+    repairActionType?: string;
+    /** For proposal events: change counts */
+    diff?: {
+        added: number;
+        modified: number;
+        removed: number;
+    };
+    /** For proposal:accepted:partial: selected vs total change count */
+    selectedCount?: number;
+    totalCount?: number;
+    /** Inferred workflow level (L1/L2/L3) for proposal events */
+    inferredLevel?: string;
+    /** For ai:error events: the raw underlying error text (HTTP status, provider message, etc.) — not shown to the user */
+    rawMessage?: string;
+}

package/dist/types/conductor.d.ts

@@ -54,7 +54,9 @@ export interface TaskDef {
     };
     sink?: string;
     evaluatorType?: 'graaljs' | 'javascript' | 'value-param' | 'python';
+    expression?: string;
     caseExpression?: string;
+    defaultExclusiveJoinTask?: string[];
     keepLastN?: number;
     forkTaskType?: string;
     forkTaskName?: string;
@@ -168,7 +170,7 @@ export interface TaskInstance {
     executed?: boolean;
     callbackFromWorker?: boolean;
     responseTimeoutSeconds?: number;
-    workflowInstanceId: string;
+    workflowInstanceId?: string;
     workflowType?: string;
     taskId: string;
     reasonForIncompletion?: string;
@@ -176,6 +178,7 @@ export interface TaskInstance {
     workerId?: string;
     externalInputPayloadStoragePath?: string;
     externalOutputPayloadStoragePath?: string;
+    workflowTask?: TaskDef;
 }
 /**
  * Conductor 工作流实例 (运行时)
@@ -184,6 +187,8 @@ export interface WorkflowInstance {
     status: 'RUNNING' | 'COMPLETED' | 'FAILED' | 'TIMED_OUT' | 'TERMINATED' | 'PAUSED';
     endTime?: number;
     workflowId: string;
+    workflowName?: string;
+    workflowVersion?: number;
     parentWorkflowId?: string;
     parentWorkflowTaskId?: string;
     tasks: TaskInstance[];