@flowget/ai-chat 0.1.0

package/dist/react.js

@@ -0,0 +1,561 @@
+"use client";
+import { createContext, useCallback, useContext, useMemo, useRef } from 'react';
+import { makeAssistantToolUI, generateId, useLocalRuntime, AssistantRuntimeProvider, AssistantModalPrimitive, ThreadListPrimitive, ThreadPrimitive, MessagePrimitive, ErrorPrimitive, ComposerPrimitive } from '@assistant-ui/react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/react/WorkflowChat.tsx
+
+// src/react/layout.ts
+var ORIGIN_X = 40;
+var ORIGIN_Y = 120;
+var COL_GAP = 240;
+var ROW_GAP = 140;
+function computeDepths(graph) {
+  const incoming = /* @__PURE__ */ new Map();
+  const children = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    incoming.set(node.id, 0);
+    children.set(node.id, []);
+  }
+  for (const edge of graph.edges) {
+    if (!incoming.has(edge.target) || !children.has(edge.source)) continue;
+    incoming.set(edge.target, (incoming.get(edge.target) ?? 0) + 1);
+    children.get(edge.source)?.push(edge.target);
+  }
+  const depth = /* @__PURE__ */ new Map();
+  const queue = graph.nodes.filter((node) => (incoming.get(node.id) ?? 0) === 0).map((node) => node.id);
+  const first = graph.nodes[0];
+  if (queue.length === 0 && first) queue.push(first.id);
+  for (const id of queue) depth.set(id, 0);
+  let guard = graph.nodes.length * graph.nodes.length + 1;
+  while (queue.length > 0 && guard-- > 0) {
+    const id = queue.shift();
+    if (id === void 0) break;
+    const current = depth.get(id) ?? 0;
+    for (const child of children.get(id) ?? []) {
+      const next = current + 1;
+      if (next > (depth.get(child) ?? -1)) {
+        depth.set(child, next);
+        queue.push(child);
+      }
+    }
+  }
+  for (const node of graph.nodes) {
+    if (!depth.has(node.id)) depth.set(node.id, 0);
+  }
+  return depth;
+}
+function layeredPositions(graph) {
+  const depth = computeDepths(graph);
+  const rowByColumn = /* @__PURE__ */ new Map();
+  const positions = /* @__PURE__ */ new Map();
+  for (const node of graph.nodes) {
+    const col = depth.get(node.id) ?? 0;
+    const row = rowByColumn.get(col) ?? 0;
+    rowByColumn.set(col, row + 1);
+    positions.set(node.id, {
+      x: ORIGIN_X + col * COL_GAP,
+      y: ORIGIN_Y + row * ROW_GAP
+    });
+  }
+  return positions;
+}
+function toCanvasEdge(edge) {
+  return {
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    // Drop `null` handles / type; the strict canvas edge wants them absent.
+    ...typeof edge.sourceHandle === "string" ? { sourceHandle: edge.sourceHandle } : {},
+    ...typeof edge.targetHandle === "string" ? { targetHandle: edge.targetHandle } : {},
+    ...typeof edge.type === "string" ? { type: edge.type } : {}
+  };
+}
+function layoutProposal(proposed, current) {
+  const currentPositions = new Map(
+    (current?.nodes ?? []).map((node) => [node.id, node.position])
+  );
+  const layered = layeredPositions(proposed);
+  const nodes = proposed.nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    data: node.data,
+    position: currentPositions.get(node.id) ?? node.position ?? layered.get(node.id) ?? { x: ORIGIN_X, y: ORIGIN_Y }
+  }));
+  return { nodes, edges: proposed.edges.map(toCanvasEdge) };
+}
+var BridgeContext = createContext(null);
+function BridgeProvider({
+  bridge,
+  children
+}) {
+  return /* @__PURE__ */ jsx(BridgeContext.Provider, { value: bridge, children });
+}
+function useBridge() {
+  const bridge = useContext(BridgeContext);
+  if (bridge === null) {
+    throw new Error("useApplyProposal must be used within <WorkflowChat>");
+  }
+  return bridge;
+}
+function applyProposal(bridge, proposed) {
+  const layout = bridge.layout ?? layoutProposal;
+  bridge.applyGraph(layout(proposed, bridge.getCurrentGraph()));
+}
+function useApplyProposal() {
+  const bridge = useBridge();
+  return useCallback(
+    (proposed) => applyProposal(bridge, proposed),
+    [bridge]
+  );
+}
+
+// src/react/contract.ts
+var PROPOSE_TOOL_NAME = "propose_workflow";
+
+// src/react/adapter.ts
+function latestUserText(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const message = messages[i];
+    if (message?.role !== "user") continue;
+    return message.content.filter(
+      (part) => part.type === "text"
+    ).map((part) => part.text).join("\n").trim();
+  }
+  return "";
+}
+function createWorkflowChatAdapter({
+  transport,
+  getCurrentGraph,
+  getRequestMeta
+}) {
+  return {
+    async *run({ messages, abortSignal, unstable_getMessage }) {
+      const inProgress = unstable_getMessage?.();
+      const decided = inProgress?.content.find(
+        (part) => part.type === "tool-call" && part.toolName === PROPOSE_TOOL_NAME && part.approval?.approved !== void 0
+      );
+      if (decided?.type === "tool-call") {
+        yield { content: [], status: { type: "complete", reason: "stop" } };
+        return;
+      }
+      const command = latestUserText(messages);
+      const meta = getRequestMeta?.() ?? {};
+      let text = "";
+      let terminal;
+      for await (const event of transport(
+        {
+          command,
+          currentGraph: getCurrentGraph(),
+          ...meta.actor !== void 0 ? { actor: meta.actor } : {},
+          ...meta.context !== void 0 ? { context: meta.context } : {}
+        },
+        abortSignal
+      )) {
+        if (event.kind === "text-delta") {
+          text += event.delta;
+          yield { content: [{ type: "text", text }], status: { type: "running" } };
+        } else if (event.kind === "message") {
+          terminal = {
+            content: [{ type: "text", text: event.text || text }],
+            status: { type: "complete", reason: "stop" }
+          };
+        } else if (event.kind === "proposal") {
+          const id = generateId();
+          const args = { graph: event.graph, summary: event.summary };
+          terminal = {
+            content: [
+              ...text ? [{ type: "text", text }] : [],
+              {
+                type: "tool-call",
+                toolCallId: id,
+                toolName: PROPOSE_TOOL_NAME,
+                args,
+                argsText: JSON.stringify(args),
+                approval: { id }
+              }
+            ],
+            status: { type: "requires-action", reason: "tool-calls" }
+          };
+        } else if (event.kind === "error") {
+          throw new Error(event.error);
+        }
+      }
+      yield terminal ?? {
+        content: [{ type: "text", text }],
+        status: { type: "complete", reason: "stop" }
+      };
+    }
+  };
+}
+
+// src/react/transport.ts
+function parseFrame(frame) {
+  const data = frame.split("\n").filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trimStart()).join("\n");
+  if (data === "") return null;
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function httpChatStreamTransport(endpoint = "/api/chat") {
+  return async function* (request, signal) {
+    const res = await fetch(endpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "text/event-stream"
+      },
+      body: JSON.stringify(request),
+      ...signal ? { signal } : {}
+    });
+    if (!res.ok || res.body === null) {
+      throw new Error(`Chat request failed (${res.status}): ${res.statusText}`);
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let sep = buffer.indexOf("\n\n");
+      while (sep !== -1) {
+        const frame = buffer.slice(0, sep);
+        buffer = buffer.slice(sep + 2);
+        const event = parseFrame(frame);
+        if (event !== null) yield event;
+        sep = buffer.indexOf("\n\n");
+      }
+    }
+    const tail = parseFrame(buffer);
+    if (tail !== null) yield tail;
+  };
+}
+function ChatRuntimeProvider({
+  children,
+  getCurrentGraph,
+  transport,
+  getRequestMeta
+}) {
+  const adapter = useMemo(
+    () => createWorkflowChatAdapter({
+      transport: transport ?? httpChatStreamTransport(),
+      getCurrentGraph,
+      ...getRequestMeta ? { getRequestMeta } : {}
+    }),
+    [transport, getCurrentGraph, getRequestMeta]
+  );
+  const runtime = useLocalRuntime(adapter);
+  return /* @__PURE__ */ jsx(AssistantRuntimeProvider, { runtime, children });
+}
+function SparkleIcon({ size = 16, className }) {
+  return /* @__PURE__ */ jsxs("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", className, "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M12 3l1.9 4.6L18.5 9.5 13.9 11.4 12 16l-1.9-4.6L5.5 9.5l4.6-1.9L12 3z",
+        fill: "currentColor"
+      }
+    ),
+    /* @__PURE__ */ jsx("path", { d: "M19 14l.8 2 2 .8-2 .8-.8 2-.8-2-2-.8 2-.8.8-2z", fill: "currentColor", opacity: "0.7" })
+  ] });
+}
+function CloseIcon({ size = 16, className }) {
+  return /* @__PURE__ */ jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", className, "aria-hidden": "true", children: /* @__PURE__ */ jsx("path", { d: "M6 6l12 12M18 6L6 18", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }) });
+}
+function SendIcon({ size = 16, className }) {
+  return /* @__PURE__ */ jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", className, "aria-hidden": "true", children: /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M12 20V5M12 5l-6 6M12 5l6 6",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+function StopIcon({ size = 14, className }) {
+  return /* @__PURE__ */ jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", className, "aria-hidden": "true", children: /* @__PURE__ */ jsx("rect", { x: "6", y: "6", width: "12", height: "12", rx: "2", fill: "currentColor" }) });
+}
+function ComposeIcon({ size = 15, className }) {
+  return /* @__PURE__ */ jsxs("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", className, "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx("path", { d: "M12 20h9", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }),
+    /* @__PURE__ */ jsx(
+      "path",
+      {
+        d: "M16.5 3.5a2.12 2.12 0 0 1 3 3L7 19l-4 1 1-4 12.5-12.5z",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    )
+  ] });
+}
+function CheckIcon({ size = 16, className }) {
+  return /* @__PURE__ */ jsx("svg", { width: size, height: size, viewBox: "0 0 24 24", fill: "none", className, "aria-hidden": "true", children: /* @__PURE__ */ jsx(
+    "path",
+    {
+      d: "M20 6L9 17l-5-5",
+      stroke: "currentColor",
+      strokeWidth: "2.2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+var DEFAULT_EXAMPLES = [
+  "Explain the workflow in a single sentence",
+  "Email ops when a new order arrives",
+  "On a schedule, fetch a URL and log the response",
+  "Add a 5-second delay before the final step"
+];
+function EmptyState({ examples }) {
+  return /* @__PURE__ */ jsxs("div", { className: "fg-aichat-empty", children: [
+    /* @__PURE__ */ jsx("span", { className: "fg-aichat-empty__mark", children: /* @__PURE__ */ jsx(SparkleIcon, { size: 22 }) }),
+    /* @__PURE__ */ jsx("p", { className: "fg-aichat-empty__title", children: "Describe a workflow" }),
+    /* @__PURE__ */ jsx("p", { className: "fg-aichat-empty__hint", children: "Tell me what it should do \u2014 I\u2019ll draft it, and you apply it to the canvas." }),
+    examples.length > 0 && /* @__PURE__ */ jsx("div", { className: "fg-aichat-empty__examples", children: examples.map((text) => /* @__PURE__ */ jsx(
+      ThreadPrimitive.Suggestion,
+      {
+        className: "fg-aichat-chip",
+        prompt: text,
+        send: true,
+        children: text
+      },
+      text
+    )) })
+  ] });
+}
+function UserMessage() {
+  return /* @__PURE__ */ jsx(MessagePrimitive.Root, { className: "fg-aichat-msg fg-aichat-msg--user", children: /* @__PURE__ */ jsx("div", { className: "fg-aichat-msg__bubble", children: /* @__PURE__ */ jsx(MessagePrimitive.Parts, {}) }) });
+}
+var ThinkingEmpty = ({ status }) => {
+  if (status.type !== "running") return null;
+  return /* @__PURE__ */ jsxs("div", { className: "fg-aichat-thinking", role: "status", children: [
+    /* @__PURE__ */ jsx("span", { className: "fg-aichat-thinking__text", children: "Thinking" }),
+    /* @__PURE__ */ jsxs("span", { className: "fg-aichat-thinking__dots", "aria-hidden": "true", children: [
+      /* @__PURE__ */ jsx("span", {}),
+      /* @__PURE__ */ jsx("span", {}),
+      /* @__PURE__ */ jsx("span", {})
+    ] })
+  ] });
+};
+var ASSISTANT_PARTS = { Empty: ThinkingEmpty };
+function AssistantMessage() {
+  return /* @__PURE__ */ jsx(MessagePrimitive.Root, { className: "fg-aichat-msg fg-aichat-msg--assistant", children: /* @__PURE__ */ jsxs("div", { className: "fg-aichat-msg__body", children: [
+    /* @__PURE__ */ jsx(MessagePrimitive.Parts, { components: ASSISTANT_PARTS }),
+    /* @__PURE__ */ jsx(MessagePrimitive.Error, { children: /* @__PURE__ */ jsx(ErrorPrimitive.Root, { className: "fg-aichat-error", children: /* @__PURE__ */ jsx(ErrorPrimitive.Message, { className: "fg-aichat-error__msg" }) }) })
+  ] }) });
+}
+function Composer() {
+  return /* @__PURE__ */ jsx("div", { className: "fg-aichat-composer", children: /* @__PURE__ */ jsxs(ComposerPrimitive.Root, { className: "fg-aichat-composer__field", children: [
+    /* @__PURE__ */ jsx(
+      ComposerPrimitive.Input,
+      {
+        className: "fg-aichat-composer__input",
+        placeholder: "Describe or edit a workflow\u2026",
+        rows: 1
+      }
+    ),
+    /* @__PURE__ */ jsx(ThreadPrimitive.If, { running: false, children: /* @__PURE__ */ jsx(ComposerPrimitive.Send, { className: "fg-aichat-send", "aria-label": "Send", children: /* @__PURE__ */ jsx(SendIcon, { size: 16 }) }) }),
+    /* @__PURE__ */ jsx(ThreadPrimitive.If, { running: true, children: /* @__PURE__ */ jsx(
+      ComposerPrimitive.Cancel,
+      {
+        className: "fg-aichat-send fg-aichat-send--stop",
+        "aria-label": "Stop",
+        children: /* @__PURE__ */ jsx(StopIcon, { size: 13 })
+      }
+    ) })
+  ] }) });
+}
+function Thread({ examples = DEFAULT_EXAMPLES } = {}) {
+  return /* @__PURE__ */ jsxs(ThreadPrimitive.Root, { className: "fg-aichat-thread", children: [
+    /* @__PURE__ */ jsxs(ThreadPrimitive.Viewport, { className: "fg-aichat-thread__viewport", children: [
+      /* @__PURE__ */ jsx(ThreadPrimitive.Empty, { children: /* @__PURE__ */ jsx(EmptyState, { examples }) }),
+      /* @__PURE__ */ jsx(
+        ThreadPrimitive.Messages,
+        {
+          components: { UserMessage, AssistantMessage }
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(Composer, {})
+  ] });
+}
+var ProposalToolUI = makeAssistantToolUI({
+  toolName: PROPOSE_TOOL_NAME,
+  display: "standalone",
+  render: function ProposalCard({ args, status, approval, respondToApproval }) {
+    const applyProposal2 = useApplyProposal();
+    if (args?.graph === void 0) {
+      return /* @__PURE__ */ jsx("div", { className: "fg-aichat-card fg-aichat-card--drafting", children: "Drafting\u2026" });
+    }
+    const { graph, summary } = args;
+    const decided = approval?.approved;
+    if (decided === true) {
+      return /* @__PURE__ */ jsxs("div", { className: "fg-aichat-applied", children: [
+        /* @__PURE__ */ jsx("span", { className: "fg-aichat-applied__badge", children: /* @__PURE__ */ jsx(CheckIcon, { size: 13 }) }),
+        /* @__PURE__ */ jsx("p", { className: "fg-aichat-applied__summary", children: summary })
+      ] });
+    }
+    if (decided === false) {
+      return /* @__PURE__ */ jsxs("div", { className: "fg-aichat-dismissed", children: [
+        /* @__PURE__ */ jsx("p", { className: "fg-aichat-dismissed__summary", children: summary }),
+        /* @__PURE__ */ jsx("span", { className: "fg-aichat-dismissed__tag", children: "Dismissed" })
+      ] });
+    }
+    const apply = () => {
+      applyProposal2(graph);
+      respondToApproval({ approved: true });
+    };
+    const dismiss = () => {
+      respondToApproval({ approved: false, reason: "Dismissed by user" });
+    };
+    const busy = status.type === "running";
+    const stepCount = graph.nodes.length;
+    return /* @__PURE__ */ jsxs("div", { className: "fg-aichat-card fg-aichat-card--proposal", children: [
+      /* @__PURE__ */ jsx("div", { className: "fg-aichat-card__label", children: "Proposed workflow" }),
+      /* @__PURE__ */ jsx("p", { className: "fg-aichat-card__summary", children: summary }),
+      /* @__PURE__ */ jsxs("div", { className: "fg-aichat-card__meta", children: [
+        stepCount,
+        " step",
+        stepCount === 1 ? "" : "s"
+      ] }),
+      /* @__PURE__ */ jsxs("div", { className: "fg-aichat-card__actions", children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "fg-aichat-btn fg-aichat-btn--ghost",
+            onClick: dismiss,
+            disabled: busy,
+            children: "Dismiss"
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            className: "fg-aichat-btn fg-aichat-btn--primary",
+            onClick: apply,
+            disabled: busy,
+            children: "Apply to canvas"
+          }
+        )
+      ] })
+    ] });
+  }
+});
+var DEFAULT_HEADING = "Workflow AI";
+var DEFAULT_SUBTITLE = "Draft & edit with a prompt";
+function ChatHeader({
+  heading,
+  subtitle
+}) {
+  return /* @__PURE__ */ jsxs("header", { className: "fg-aichat-dock__head", children: [
+    /* @__PURE__ */ jsxs("div", { className: "fg-aichat-dock__brand", children: [
+      /* @__PURE__ */ jsx("span", { className: "fg-aichat-dock__mark", children: /* @__PURE__ */ jsx(SparkleIcon, { size: 15 }) }),
+      /* @__PURE__ */ jsxs("div", { children: [
+        /* @__PURE__ */ jsx("div", { className: "fg-aichat-dock__title", children: heading }),
+        /* @__PURE__ */ jsx("div", { className: "fg-aichat-dock__subtitle", children: subtitle })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs(ThreadListPrimitive.New, { className: "fg-aichat-newchat", children: [
+      /* @__PURE__ */ jsx(ComposeIcon, { size: 14 }),
+      /* @__PURE__ */ jsx("span", { children: "New chat" })
+    ] })
+  ] });
+}
+function WorkflowChat({
+  currentGraph,
+  applyGraph,
+  transport,
+  endpoint,
+  heading = DEFAULT_HEADING,
+  subtitle = DEFAULT_SUBTITLE,
+  examples,
+  layout,
+  actor,
+  context
+}) {
+  const graphRef = useRef(currentGraph);
+  graphRef.current = currentGraph;
+  const applyRef = useRef(applyGraph);
+  applyRef.current = applyGraph;
+  const layoutRef = useRef(layout);
+  layoutRef.current = layout;
+  const metaRef = useRef({});
+  metaRef.current = {
+    ...actor !== void 0 ? { actor } : {},
+    ...context !== void 0 ? { context } : {}
+  };
+  const bridge = useMemo(
+    () => ({
+      getCurrentGraph: () => graphRef.current,
+      applyGraph: (graph) => applyRef.current(graph),
+      layout: (proposed, current) => (layoutRef.current ?? layoutProposal)(proposed, current)
+    }),
+    []
+  );
+  const resolvedTransport = useMemo(
+    () => transport ?? httpChatStreamTransport(endpoint),
+    [transport, endpoint]
+  );
+  const getCurrentGraph = useCallback(() => graphRef.current, []);
+  const getRequestMeta = useCallback(() => metaRef.current, []);
+  return /* @__PURE__ */ jsx(BridgeProvider, { bridge, children: /* @__PURE__ */ jsxs(
+    ChatRuntimeProvider,
+    {
+      getCurrentGraph,
+      transport: resolvedTransport,
+      getRequestMeta,
+      children: [
+        /* @__PURE__ */ jsxs(AssistantModalPrimitive.Root, { children: [
+          /* @__PURE__ */ jsx(AssistantModalPrimitive.Anchor, { className: "fg-aichat-anchor", children: /* @__PURE__ */ jsxs(
+            AssistantModalPrimitive.Trigger,
+            {
+              className: "fg-aichat-launcher",
+              "aria-label": "Toggle workflow AI",
+              children: [
+                /* @__PURE__ */ jsx(
+                  SparkleIcon,
+                  {
+                    size: 20,
+                    className: "fg-aichat-launcher__icon fg-aichat-launcher__icon--open"
+                  }
+                ),
+                /* @__PURE__ */ jsx(
+                  CloseIcon,
+                  {
+                    size: 20,
+                    className: "fg-aichat-launcher__icon fg-aichat-launcher__icon--close"
+                  }
+                )
+              ]
+            }
+          ) }),
+          /* @__PURE__ */ jsxs(
+            AssistantModalPrimitive.Content,
+            {
+              className: "fg-aichat-panel",
+              side: "top",
+              align: "end",
+              sideOffset: 12,
+              children: [
+                /* @__PURE__ */ jsx(ChatHeader, { heading, subtitle }),
+                /* @__PURE__ */ jsx(Thread, { ...examples !== void 0 ? { examples } : {} })
+              ]
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx(ProposalToolUI, {})
+      ]
+    }
+  ) });
+}
+
+export { ChatRuntimeProvider, WorkflowChat, createWorkflowChatAdapter, httpChatStreamTransport, layoutProposal };

package/dist/server.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+var ai = require('@flowget/ai');
+
+// src/server/index.ts
+var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+var DEFAULT_MAX_COMMAND_LENGTH = 8e3;
+async function parseChatRequest(req, limits = {}) {
+  const maxBodyBytes = limits.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  const maxCommandLength = limits.maxCommandLength ?? DEFAULT_MAX_COMMAND_LENGTH;
+  const declared = Number(req.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maxBodyBytes) return null;
+  let text;
+  try {
+    text = await req.text();
+  } catch {
+    return null;
+  }
+  if (text.length > maxBodyBytes) return null;
+  let body;
+  try {
+    body = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (body === null || typeof body !== "object" || Array.isArray(body)) {
+    return null;
+  }
+  const record = body;
+  const command = typeof record.command === "string" ? record.command : "";
+  if (command.trim() === "" || command.length > maxCommandLength) return null;
+  const currentGraph = record.currentGraph !== null && typeof record.currentGraph === "object" && !Array.isArray(record.currentGraph) ? record.currentGraph : void 0;
+  const actor = record.actor !== null && typeof record.actor === "object" && !Array.isArray(record.actor) ? record.actor : void 0;
+  return {
+    command,
+    ...currentGraph !== void 0 ? { currentGraph } : {},
+    ...actor !== void 0 ? { actor } : {},
+    ...record.context !== void 0 ? { context: record.context } : {}
+  };
+}
+function sseFrame(event) {
+  return `data: ${JSON.stringify(event)}
+
+`;
+}
+var SSE_HEADERS = {
+  "content-type": "text/event-stream",
+  "cache-control": "no-cache, no-transform",
+  // Disable proxy buffering (nginx) so events flush as they're produced.
+  "x-accel-buffering": "no"
+};
+function streamAuthorSSE(request, config, options = {}) {
+  const { signal, onError } = options;
+  const stream = new ReadableStream({
+    async start(controller) {
+      const encoder = new TextEncoder();
+      let closed = false;
+      const send = (event) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(sseFrame(event)));
+        } catch {
+          closed = true;
+        }
+      };
+      try {
+        const resolved = typeof config === "function" ? await config(request) : config;
+        for await (const event of ai.authorStream(resolved, request, {
+          ...signal ? { signal } : {}
+        })) {
+          send(event);
+        }
+      } catch (err) {
+        console.error("[@flowget/ai-chat] authoring stream failed:", err);
+        send({
+          kind: "error",
+          error: onError ? onError(err) : "Authoring failed"
+        });
+      } finally {
+        closed = true;
+        try {
+          controller.close();
+        } catch {
+        }
+      }
+    }
+  });
+  return new Response(stream, { status: 200, headers: { ...SSE_HEADERS } });
+}
+async function createChatStreamResponse(req, config, options = {}) {
+  const { buildRequest, onError, ...limits } = options;
+  const parsed = await parseChatRequest(req, limits);
+  if (parsed === null) {
+    const body = sseFrame({ kind: "error", error: "Invalid request" });
+    return new Response(body, { status: 200, headers: { ...SSE_HEADERS } });
+  }
+  let request = parsed;
+  if (buildRequest) {
+    try {
+      request = await buildRequest(parsed, req);
+    } catch (err) {
+      console.error("[@flowget/ai-chat] buildRequest failed:", err);
+      const body = sseFrame({
+        kind: "error",
+        error: onError ? onError(err) : "Authoring failed"
+      });
+      return new Response(body, { status: 200, headers: { ...SSE_HEADERS } });
+    }
+  }
+  return streamAuthorSSE(request, config, {
+    ...req.signal ? { signal: req.signal } : {},
+    ...onError ? { onError } : {}
+  });
+}
+
+exports.createChatStreamResponse = createChatStreamResponse;
+exports.parseChatRequest = parseChatRequest;
+exports.streamAuthorSSE = streamAuthorSSE;