@yiyi_zhang/reactflow-ui 0.3.0 → 0.5.0-beta.0

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;
@@ -18,6 +20,26 @@ export declare const callAICopilot: (messages: ChatMessage[], config?: Partial<A
  * 流式调用 - 通过 onToken 回调逐 token 返回内容
  */
 export declare const callAICopilotStream: (messages: ChatMessage[], config: Partial<AIServiceConfig> | undefined, onToken: (token: string) => void, onDone?: () => void, signal?: AbortSignal) => Promise<string>;
+/**
+ * 生成任务 inputParameters 的 AI prompt（P4.1）
+ */
+export declare const generateTaskParametersPrompt: (taskType: string, taskRef: string, workflowInputParams: string[], upstreamTasks: Array<{
+    ref: string;
+    type: string;
+    name: string;
+}>, currentParams: Record<string, any>) => string;
+/**
+ * System Prompt for execution analysis / fault diagnosis（P4.3）
+ */
+export declare const EXECUTION_ANALYSIS_SYSTEM_PROMPT = "\nYou are a Netflix Conductor workflow debugging expert.\nWhen given a failed workflow execution, you analyze the task inputs, outputs, and errors to diagnose root causes.\n\nFocus on:\n1. JSONPath expressions that failed to resolve (NullPointerException, PathNotFoundException)\n2. Wrong or missing parameter fields for the task type\n3. Type mismatches between upstream output and task input\n4. Timeout and retry configuration issues\n5. HTTP error codes and what they imply about the request parameters\n\nAlways respond in Chinese. Be concise and actionable.\nIf you suggest a fix, describe specifically which task and which parameter field to change.\n";
+/**
+ * AI 自动生成任务 inputParameters（P4.1）
+ */
+export declare const generateTaskParameters: (taskType: string, taskRef: string, workflowInputParams: string[], upstreamTasks: Array<{
+    ref: string;
+    type: string;
+    name: string;
+}>, currentParams: Record<string, any>, config?: Partial<AIServiceConfig>) => Promise<Record<string, any>>;
 /**
  * System Prompt for Conductor Workflow Modeling
  */

package/dist/stateDiagram-AJRCARHV-Rv1mSmnJ.js

@@ -0,0 +1,263 @@
+import { s as A, a as W, S as N } from "./chunk-AQP2D5EJ-Os2Uwqya.js";
+import { _ as f, c as t, d as H, l as S, e as P, k as z, R as _, S as U, O as C, u as F } from "./mermaid.core-XSpZEAKP.js";
+import { G as O } from "./graph-BRoPeNF3.js";
+import { l as J } from "./layout-D9EpM4Fg.js";
+var X = /* @__PURE__ */ f((e) => e.append("circle").attr("class", "start-state").attr("r", t().state.sizeUnit).attr("cx", t().state.padding + t().state.sizeUnit).attr("cy", t().state.padding + t().state.sizeUnit), "drawStartState"), D = /* @__PURE__ */ f((e) => e.append("line").style("stroke", "grey").style("stroke-dasharray", "3").attr("x1", t().state.textHeight).attr("class", "divider").attr("x2", t().state.textHeight * 2).attr("y1", 0).attr("y2", 0), "drawDivider"), Y = /* @__PURE__ */ f((e, i) => {
+  const d = e.append("text").attr("x", 2 * t().state.padding).attr("y", t().state.textHeight + 2 * t().state.padding).attr("font-size", t().state.fontSize).attr("class", "state-title").text(i.id), c = d.node().getBBox();
+  return e.insert("rect", ":first-child").attr("x", t().state.padding).attr("y", t().state.padding).attr("width", c.width + 2 * t().state.padding).attr("height", c.height + 2 * t().state.padding).attr("rx", t().state.radius), d;
+}, "drawSimpleState"), I = /* @__PURE__ */ f((e, i) => {
+  const d = /* @__PURE__ */ f(function(o, m, y) {
+    const v = o.append("tspan").attr("x", 2 * t().state.padding).text(m);
+    y || v.attr("dy", t().state.textHeight);
+  }, "addTspan"), n = e.append("text").attr("x", 2 * t().state.padding).attr("y", t().state.textHeight + 1.3 * t().state.padding).attr("font-size", t().state.fontSize).attr("class", "state-title").text(i.descriptions[0]).node().getBBox(), l = n.height, p = e.append("text").attr("x", t().state.padding).attr(
+    "y",
+    l + t().state.padding * 0.4 + t().state.dividerMargin + t().state.textHeight
+  ).attr("class", "state-description");
+  let a = !0, s = !0;
+  i.descriptions.forEach(function(o) {
+    a || (d(p, o, s), s = !1), a = !1;
+  });
+  const B = e.append("line").attr("x1", t().state.padding).attr("y1", t().state.padding + l + t().state.dividerMargin / 2).attr("y2", t().state.padding + l + t().state.dividerMargin / 2).attr("class", "descr-divider"), x = p.node().getBBox(), g = Math.max(x.width, n.width);
+  return B.attr("x2", g + 3 * t().state.padding), e.insert("rect", ":first-child").attr("x", t().state.padding).attr("y", t().state.padding).attr("width", g + 2 * t().state.padding).attr("height", x.height + l + 2 * t().state.padding).attr("rx", t().state.radius), e;
+}, "drawDescrState"), $ = /* @__PURE__ */ f((e, i, d) => {
+  const c = t().state.padding, n = 2 * t().state.padding, l = e.node().getBBox(), p = l.width, a = l.x, s = e.append("text").attr("x", 0).attr("y", t().state.titleShift).attr("font-size", t().state.fontSize).attr("class", "state-title").text(i.id), x = s.node().getBBox().width + n;
+  let g = Math.max(x, p);
+  g === p && (g = g + n);
+  let o;
+  const m = e.node().getBBox();
+  i.doc, o = a - c, x > p && (o = (p - g) / 2 + c), Math.abs(a - m.x) < c && x > p && (o = a - (x - p) / 2);
+  const y = 1 - t().state.textHeight;
+  return e.insert("rect", ":first-child").attr("x", o).attr("y", y).attr("class", d ? "alt-composit" : "composit").attr("width", g).attr(
+    "height",
+    m.height + t().state.textHeight + t().state.titleShift + 1
+  ).attr("rx", "0"), s.attr("x", o + c), x <= p && s.attr("x", a + (g - n) / 2 - x / 2 + c), e.insert("rect", ":first-child").attr("x", o).attr(
+    "y",
+    t().state.titleShift - t().state.textHeight - t().state.padding
+  ).attr("width", g).attr("height", t().state.textHeight * 3).attr("rx", t().state.radius), e.insert("rect", ":first-child").attr("x", o).attr(
+    "y",
+    t().state.titleShift - t().state.textHeight - t().state.padding
+  ).attr("width", g).attr("height", m.height + 3 + 2 * t().state.textHeight).attr("rx", t().state.radius), e;
+}, "addTitleAndBox"), q = /* @__PURE__ */ f((e) => (e.append("circle").attr("class", "end-state-outer").attr("r", t().state.sizeUnit + t().state.miniPadding).attr(
+  "cx",
+  t().state.padding + t().state.sizeUnit + t().state.miniPadding
+).attr(
+  "cy",
+  t().state.padding + t().state.sizeUnit + t().state.miniPadding
+), e.append("circle").attr("class", "end-state-inner").attr("r", t().state.sizeUnit).attr("cx", t().state.padding + t().state.sizeUnit + 2).attr("cy", t().state.padding + t().state.sizeUnit + 2)), "drawEndState"), Z = /* @__PURE__ */ f((e, i) => {
+  let d = t().state.forkWidth, c = t().state.forkHeight;
+  if (i.parentId) {
+    let n = d;
+    d = c, c = n;
+  }
+  return e.append("rect").style("stroke", "black").style("fill", "black").attr("width", d).attr("height", c).attr("x", t().state.padding).attr("y", t().state.padding);
+}, "drawForkJoinState"), j = /* @__PURE__ */ f((e, i, d, c) => {
+  let n = 0;
+  const l = c.append("text");
+  l.style("text-anchor", "start"), l.attr("class", "noteText");
+  let p = e.replace(/\r\n/g, "<br/>");
+  p = p.replace(/\n/g, "<br/>");
+  const a = p.split(z.lineBreakRegex);
+  let s = 1.25 * t().state.noteMargin;
+  for (const B of a) {
+    const x = B.trim();
+    if (x.length > 0) {
+      const g = l.append("tspan");
+      if (g.text(x), s === 0) {
+        const o = g.node().getBBox();
+        s += o.height;
+      }
+      n += s, g.attr("x", i + t().state.noteMargin), g.attr("y", d + n + 1.25 * t().state.noteMargin);
+    }
+  }
+  return { textWidth: l.node().getBBox().width, textHeight: n };
+}, "_drawLongText"), K = /* @__PURE__ */ f((e, i) => {
+  i.attr("class", "state-note");
+  const d = i.append("rect").attr("x", 0).attr("y", t().state.padding), c = i.append("g"), { textWidth: n, textHeight: l } = j(e, 0, 0, c);
+  return d.attr("height", l + 2 * t().state.noteMargin), d.attr("width", n + t().state.noteMargin * 2), d;
+}, "drawNote"), L = /* @__PURE__ */ f(function(e, i) {
+  const d = i.id, c = {
+    id: d,
+    label: i.id,
+    width: 0,
+    height: 0
+  }, n = e.append("g").attr("id", d).attr("class", "stateGroup");
+  i.type === "start" && X(n), i.type === "end" && q(n), (i.type === "fork" || i.type === "join") && Z(n, i), i.type === "note" && K(i.note.text, n), i.type === "divider" && D(n), i.type === "default" && i.descriptions.length === 0 && Y(n, i), i.type === "default" && i.descriptions.length > 0 && I(n, i);
+  const l = n.node().getBBox();
+  return c.width = l.width + 2 * t().state.padding, c.height = l.height + 2 * t().state.padding, c;
+}, "drawState"), G = 0, Q = /* @__PURE__ */ f(function(e, i, d) {
+  const c = /* @__PURE__ */ f(function(s) {
+    switch (s) {
+      case N.relationType.AGGREGATION:
+        return "aggregation";
+      case N.relationType.EXTENSION:
+        return "extension";
+      case N.relationType.COMPOSITION:
+        return "composition";
+      case N.relationType.DEPENDENCY:
+        return "dependency";
+    }
+  }, "getRelationType");
+  i.points = i.points.filter((s) => !Number.isNaN(s.y));
+  const n = i.points, l = _().x(function(s) {
+    return s.x;
+  }).y(function(s) {
+    return s.y;
+  }).curve(U), p = e.append("path").attr("d", l(n)).attr("id", "edge" + G).attr("class", "transition");
+  let a = "";
+  if (t().state.arrowMarkerAbsolute && (a = C(!0)), p.attr(
+    "marker-end",
+    "url(" + a + "#" + c(N.relationType.DEPENDENCY) + "End)"
+  ), d.title !== void 0) {
+    const s = e.append("g").attr("class", "stateLabel"), { x: B, y: x } = F.calcLabelPosition(i.points), g = z.getRows(d.title);
+    let o = 0;
+    const m = [];
+    let y = 0, v = 0;
+    for (let u = 0; u <= g.length; u++) {
+      const h = s.append("text").attr("text-anchor", "middle").text(g[u]).attr("x", B).attr("y", x + o), w = h.node().getBBox();
+      y = Math.max(y, w.width), v = Math.min(v, w.x), S.info(w.x, B, x + o), o === 0 && (o = h.node().getBBox().height, S.info("Title height", o, x)), m.push(h);
+    }
+    let k = o * g.length;
+    if (g.length > 1) {
+      const u = (g.length - 1) * o * 0.5;
+      m.forEach((h, w) => h.attr("y", x + w * o - u)), k = o * g.length;
+    }
+    const r = s.node().getBBox();
+    s.insert("rect", ":first-child").attr("class", "box").attr("x", B - y / 2 - t().state.padding / 2).attr("y", x - k / 2 - t().state.padding / 2 - 3.5).attr("width", y + t().state.padding).attr("height", k + t().state.padding), S.info(r);
+  }
+  G++;
+}, "drawEdge"), b, T = {}, V = /* @__PURE__ */ f(function() {
+}, "setConf"), tt = /* @__PURE__ */ f(function(e) {
+  e.append("defs").append("marker").attr("id", "dependencyEnd").attr("refX", 19).attr("refY", 7).attr("markerWidth", 20).attr("markerHeight", 28).attr("orient", "auto").append("path").attr("d", "M 19,7 L9,13 L14,7 L9,1 Z");
+}, "insertMarkers"), et = /* @__PURE__ */ f(function(e, i, d, c) {
+  b = t().state;
+  const n = t().securityLevel;
+  let l;
+  n === "sandbox" && (l = H("#i" + i));
+  const p = n === "sandbox" ? H(l.nodes()[0].contentDocument.body) : H("body"), a = n === "sandbox" ? l.nodes()[0].contentDocument : document;
+  S.debug("Rendering diagram " + e);
+  const s = p.select(`[id='${i}']`);
+  tt(s);
+  const B = c.db.getRootDoc(), x = s.append("g").attr("id", i + "-root");
+  R(B, x, void 0, !1, p, a, c);
+  const g = b.padding, o = s.node().getBBox(), m = o.width + g * 2, y = o.height + g * 2, v = m * 1.75;
+  P(s, y, v, b.useMaxWidth), s.attr(
+    "viewBox",
+    `${o.x - b.padding}  ${o.y - b.padding} ` + m + " " + y
+  );
+}, "draw"), at = /* @__PURE__ */ f((e) => e ? e.length * b.fontSizeFactor : 1, "getLabelWidth"), R = /* @__PURE__ */ f((e, i, d, c, n, l, p) => {
+  const a = new O({
+    compound: !0,
+    multigraph: !0
+  });
+  let s, B = !0;
+  for (s = 0; s < e.length; s++)
+    if (e[s].stmt === "relation") {
+      B = !1;
+      break;
+    }
+  d ? a.setGraph({
+    rankdir: "LR",
+    multigraph: !0,
+    compound: !0,
+    // acyclicer: 'greedy',
+    ranker: "tight-tree",
+    ranksep: B ? 1 : b.edgeLengthFactor,
+    nodeSep: B ? 1 : 50,
+    isMultiGraph: !0
+    // ranksep: 5,
+    // nodesep: 1
+  }) : a.setGraph({
+    rankdir: "TB",
+    multigraph: !0,
+    compound: !0,
+    // isCompound: true,
+    // acyclicer: 'greedy',
+    // ranker: 'longest-path'
+    ranksep: B ? 1 : b.edgeLengthFactor,
+    nodeSep: B ? 1 : 50,
+    ranker: "tight-tree",
+    // ranker: 'network-simplex'
+    isMultiGraph: !0
+  }), a.setDefaultEdgeLabel(function() {
+    return {};
+  });
+  const x = p.db.getStates(), g = p.db.getRelations(), o = Object.keys(x);
+  for (const r of o) {
+    const u = x[r];
+    d && (u.parentId = d);
+    let h;
+    if (u.doc) {
+      let w = i.append("g").attr("id", u.id).attr("class", "stateGroup");
+      h = R(u.doc, w, u.id, !c, n, l, p);
+      {
+        w = $(w, u, c);
+        let E = w.node().getBBox();
+        h.width = E.width, h.height = E.height + b.padding / 2, T[u.id] = { y: b.compositTitleSize };
+      }
+    } else
+      h = L(i, u, a);
+    if (u.note) {
+      const w = {
+        descriptions: [],
+        id: u.id + "-note",
+        note: u.note,
+        type: "note"
+      }, E = L(i, w, a);
+      u.note.position === "left of" ? (a.setNode(h.id + "-note", E), a.setNode(h.id, h)) : (a.setNode(h.id, h), a.setNode(h.id + "-note", E)), a.setParent(h.id, h.id + "-group"), a.setParent(h.id + "-note", h.id + "-group");
+    } else
+      a.setNode(h.id, h);
+  }
+  S.debug("Count=", a.nodeCount(), a);
+  let m = 0;
+  g.forEach(function(r) {
+    m++, S.debug("Setting edge", r), a.setEdge(
+      r.id1,
+      r.id2,
+      {
+        relation: r,
+        width: at(r.title),
+        height: b.labelHeight * z.getRows(r.title).length,
+        labelpos: "c"
+      },
+      "id" + m
+    );
+  }), J(a), S.debug("Graph after layout", a.nodes());
+  const y = i.node();
+  a.nodes().forEach(function(r) {
+    r !== void 0 && a.node(r) !== void 0 ? (S.warn("Node " + r + ": " + JSON.stringify(a.node(r))), n.select("#" + y.id + " #" + r).attr(
+      "transform",
+      "translate(" + (a.node(r).x - a.node(r).width / 2) + "," + (a.node(r).y + (T[r] ? T[r].y : 0) - a.node(r).height / 2) + " )"
+    ), n.select("#" + y.id + " #" + r).attr("data-x-shift", a.node(r).x - a.node(r).width / 2), l.querySelectorAll("#" + y.id + " #" + r + " .divider").forEach((h) => {
+      const w = h.parentElement;
+      let E = 0, M = 0;
+      w && (w.parentElement && (E = w.parentElement.getBBox().width), M = parseInt(w.getAttribute("data-x-shift"), 10), Number.isNaN(M) && (M = 0)), h.setAttribute("x1", 0 - M + 8), h.setAttribute("x2", E - M - 8);
+    })) : S.debug("No Node " + r + ": " + JSON.stringify(a.node(r)));
+  });
+  let v = y.getBBox();
+  a.edges().forEach(function(r) {
+    r !== void 0 && a.edge(r) !== void 0 && (S.debug("Edge " + r.v + " -> " + r.w + ": " + JSON.stringify(a.edge(r))), Q(i, a.edge(r), a.edge(r).relation));
+  }), v = y.getBBox();
+  const k = {
+    id: d || "root",
+    label: d || "root",
+    width: 0,
+    height: 0
+  };
+  return k.width = v.width + 2 * b.padding, k.height = v.height + 2 * b.padding, S.debug("Doc rendered", k, a), k;
+}, "renderDoc"), it = {
+  setConf: V,
+  draw: et
+}, ot = {
+  parser: W,
+  get db() {
+    return new N(1);
+  },
+  renderer: it,
+  styles: A,
+  init: /* @__PURE__ */ f((e) => {
+    e.state || (e.state = {}), e.state.arrowMarkerAbsolute = e.arrowMarkerAbsolute;
+  }, "init")
+};
+export {
+  ot as diagram
+};

package/dist/stateDiagram-v2-BHNVJYJU-BME16k02.js

@@ -0,0 +1,16 @@
+import { s as a, b as t, a as r, S as s } from "./chunk-AQP2D5EJ-Os2Uwqya.js";
+import { _ as i } from "./mermaid.core-XSpZEAKP.js";
+var _ = {
+  parser: r,
+  get db() {
+    return new s(2);
+  },
+  renderer: t,
+  styles: a,
+  init: /* @__PURE__ */ i((e) => {
+    e.state || (e.state = {}), e.state.arrowMarkerAbsolute = e.arrowMarkerAbsolute;
+  }, "init")
+};
+export {
+  _ as diagram
+};

package/dist/store/aiStore.d.ts

@@ -0,0 +1,199 @@
+/**
+ * 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 } from '../services/ai/protocolAdapter';
+import type { WorkflowDef } from '../types/conductor';
+import type { DiffSummary } from '../services/ai/toolExecutor';
+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;
+    /** 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;
+}
+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[];
+}
+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 from a persisted draft (M1.4) */
+    hydrateFromDraft: (messages: AiChatMessage[], pendingProposal: ProposedChange | null) => void;
+    setToolStatus: (status: string) => void;
+    setRetryInput: (input: string | null) => void;
+    addTimelineEntry: (label: string, icon?: 'done' | 'warning') => void;
+    clearTimeline: () => 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;