@nocobase/portal-template-default 1.0.3 → 1.0.5

package/src/extensions/nocobase-ai/providers/ui-message-stream.ts

@@ -1,463 +0,0 @@
-import type { InferUIMessageChunk } from "ai";
-import { parseNocoBaseSSE, type NocoBaseStreamEvent } from "./stream-parser";
-import { StreamCoalescer } from "./stream-coalescer";
-import {
-  getToolCallState,
-  getToolProviderMetadata,
-  isRecord,
-  parseToolInput,
-  toolCallsFromEvent,
-  type NocoBaseToolCall,
-} from "./stream-event-utils";
-import { SubAgentStreamAccumulator } from "./sub-agent-stream";
-import type { AIChatMessage } from "./types";
-
-const VISUAL_DELTA_FLUSH_INTERVAL = 50;
-const VISUAL_DELTA_FLUSH_SIZE = 768;
-const TOOL_INPUT_FLUSH_INTERVAL = 50;
-const TOOL_INPUT_FLUSH_SIZE = 2048;
-
-type AIChatChunk = InferUIMessageChunk<AIChatMessage>;
-
-type BufferedVisualDelta = {
-  type: "text-delta" | "reasoning-delta";
-  id: string;
-  delta: string;
-};
-
-type BufferedSubAgentEvent = {
-  event: NocoBaseStreamEvent;
-  content: string;
-};
-
-type BufferedSubAgentToolEvent = {
-  event: NocoBaseStreamEvent;
-  chunks: NocoBaseToolCall[];
-  size: number;
-};
-
-const reasoningContent = (event: NocoBaseStreamEvent) => {
-  if (typeof event.body === "object" && event.body) {
-    const content = (event.body as { content?: unknown }).content;
-    return typeof content === "string" ? content : "";
-  }
-  return "";
-};
-
-const mergeToolCallChunks = (
-  current: BufferedSubAgentToolEvent,
-  incoming: BufferedSubAgentToolEvent
-) => {
-  const chunks = current.chunks.map((chunk) => ({ ...chunk }));
-  for (const chunk of incoming.chunks) {
-    const last = chunks.at(-1);
-    if (
-      last &&
-      !chunk.name &&
-      (chunk.id === undefined || chunk.id === last.id) &&
-      (chunk.index === undefined || chunk.index === last.index) &&
-      typeof chunk.args === "string"
-    ) {
-      last.args = `${typeof last.args === "string" ? last.args : ""}${
-        chunk.args
-      }`;
-    } else {
-      chunks.push({ ...chunk });
-    }
-  }
-  return {
-    event: incoming.event,
-    chunks,
-    size: current.size + incoming.size,
-  };
-};
-
-export function createNocoBaseUIMessageStream(
-  stream: ReadableStream<Uint8Array>,
-  messageId: string | null = `assistant-${crypto.randomUUID()}`,
-  options: { waitForNewMessage?: boolean; seedMessage?: AIChatMessage } = {}
-): ReadableStream<AIChatChunk> {
-  return new ReadableStream<AIChatChunk>({
-    async start(controller) {
-      let textId = `text-${crypto.randomUUID()}`;
-      let reasoningId = `reasoning-${crypto.randomUUID()}`;
-      let textStarted = false;
-      let reasoningStarted = false;
-      let currentToolCallId: string | undefined;
-      let responseStarted = options.waitForNewMessage !== true;
-      const announcedToolCalls = new Set<string>();
-      const toolCallNames = new Map<string, string>();
-      const toolCallInputs = new Map<string, unknown>();
-      const subAgents = new SubAgentStreamAccumulator(options.seedMessage);
-      controller.enqueue(
-        messageId === null ? { type: "start" } : { type: "start", messageId }
-      );
-
-      const visualDeltas = new StreamCoalescer<string, BufferedVisualDelta>({
-        interval: VISUAL_DELTA_FLUSH_INTERVAL,
-        maxSize: VISUAL_DELTA_FLUSH_SIZE,
-        getSize: (value) => value.delta.length,
-        merge: (current, incoming) => ({
-          ...incoming,
-          delta: `${current.delta}${incoming.delta}`,
-        }),
-        onFlush: (_, value) => controller.enqueue(value),
-      });
-
-      const toolInputDeltas = new StreamCoalescer<string, string>({
-        interval: TOOL_INPUT_FLUSH_INTERVAL,
-        maxSize: TOOL_INPUT_FLUSH_SIZE,
-        getSize: (value) => value.length,
-        merge: (current, incoming) => `${current}${incoming}`,
-        onFlush: (toolCallId, inputTextDelta) => {
-          controller.enqueue({
-            type: "tool-input-delta",
-            toolCallId,
-            inputTextDelta,
-          });
-        },
-      });
-
-      const subAgentToolEvents = new StreamCoalescer<
-        string,
-        BufferedSubAgentToolEvent
-      >({
-        interval: TOOL_INPUT_FLUSH_INTERVAL,
-        maxSize: TOOL_INPUT_FLUSH_SIZE,
-        getSize: (value) => value.size,
-        merge: mergeToolCallChunks,
-        onFlush: (_, value) => {
-          for (const chunk of subAgents.process({
-            ...value.event,
-            body: value.chunks,
-          })) {
-            controller.enqueue(chunk);
-          }
-        },
-      });
-
-      const enqueueSubAgentToolEvent = (event: NocoBaseStreamEvent) => {
-        const sessionId = event.sessionId;
-        if (!sessionId) return;
-        const chunks = toolCallsFromEvent(event);
-        subAgentToolEvents.push(sessionId, {
-          event,
-          chunks,
-          size: chunks.reduce(
-            (size, chunk) =>
-              size + (typeof chunk.args === "string" ? chunk.args.length : 0),
-            0
-          ),
-        });
-      };
-
-      const enqueueVisualDelta = (chunk: BufferedVisualDelta) => {
-        visualDeltas.push(`${chunk.type}:${chunk.id}`, chunk);
-      };
-
-      const subAgentNarrativeEvents = new StreamCoalescer<
-        string,
-        BufferedSubAgentEvent
-      >({
-        interval: VISUAL_DELTA_FLUSH_INTERVAL,
-        maxSize: VISUAL_DELTA_FLUSH_SIZE,
-        getSize: (value) => value.content.length,
-        merge: (current, incoming) => ({
-          event: incoming.event,
-          content: `${current.content}${incoming.content}`,
-        }),
-        onFlush: (_, pending) => {
-          const body =
-            pending.event.type === "reasoning" && isRecord(pending.event.body)
-              ? { ...pending.event.body, content: pending.content }
-              : pending.content;
-          for (const chunk of subAgents.process({ ...pending.event, body })) {
-            controller.enqueue(chunk);
-          }
-        },
-      });
-
-      const subAgentNarrativeKey = (sessionId: string, type: string) =>
-        `${sessionId}:${type}`;
-
-      const flushSubAgentNarrativeEvents = (sessionId?: string) => {
-        if (!sessionId) {
-          subAgentNarrativeEvents.flushAll();
-          return;
-        }
-        subAgentNarrativeEvents.flush(
-          subAgentNarrativeKey(sessionId, "reasoning")
-        );
-        subAgentNarrativeEvents.flush(
-          subAgentNarrativeKey(sessionId, "content")
-        );
-      };
-
-      const enqueueSubAgentNarrativeEvent = (event: NocoBaseStreamEvent) => {
-        const sessionId = event.sessionId;
-        if (!sessionId) return;
-        const content =
-          event.type === "content" && typeof event.body === "string"
-            ? event.body
-            : event.type === "reasoning" && isRecord(event.body)
-            ? typeof event.body.content === "string"
-              ? event.body.content
-              : ""
-            : "";
-        if (!content) return;
-        const otherType = event.type === "content" ? "reasoning" : "content";
-        subAgentNarrativeEvents.flush(
-          subAgentNarrativeKey(sessionId, otherType)
-        );
-        subAgentNarrativeEvents.push(
-          subAgentNarrativeKey(sessionId, event.type),
-          { event, content }
-        );
-      };
-
-      const finishActiveText = () => {
-        if (!textStarted) return;
-        visualDeltas.flush(`text-delta:${textId}`);
-        controller.enqueue({ type: "text-end", id: textId });
-        textStarted = false;
-        textId = `text-${crypto.randomUUID()}`;
-      };
-
-      const finishActiveReasoning = () => {
-        if (!reasoningStarted) return;
-        visualDeltas.flush(`reasoning-delta:${reasoningId}`);
-        controller.enqueue({ type: "reasoning-end", id: reasoningId });
-        reasoningStarted = false;
-        reasoningId = `reasoning-${crypto.randomUUID()}`;
-      };
-
-      const finishActiveNarrative = () => {
-        finishActiveReasoning();
-        finishActiveText();
-      };
-
-      try {
-        for await (const event of parseNocoBaseSSE(stream)) {
-          if (event.type !== "tool_call_chunks") {
-            toolInputDeltas.flushAll();
-          }
-          if (event.from === "sub-agent") {
-            finishActiveNarrative();
-            if (event.type === "content" || event.type === "reasoning") {
-              if (event.sessionId) subAgentToolEvents.flush(event.sessionId);
-              enqueueSubAgentNarrativeEvent(event);
-              continue;
-            }
-            flushSubAgentNarrativeEvents(event.sessionId);
-            if (event.type === "tool_call_chunks") {
-              enqueueSubAgentToolEvent(event);
-              continue;
-            }
-            if (event.sessionId) subAgentToolEvents.flush(event.sessionId);
-            for (const chunk of subAgents.process(event)) {
-              controller.enqueue(chunk);
-            }
-            continue;
-          }
-
-          flushSubAgentNarrativeEvents();
-          subAgentToolEvents.flushAll();
-
-          if (event.type === "new_message") {
-            responseStarted = true;
-            continue;
-          }
-
-          if (!responseStarted && event.type !== "error") {
-            continue;
-          }
-
-          if (event.type === "content" && typeof event.body === "string") {
-            finishActiveReasoning();
-            if (!textStarted) {
-              controller.enqueue({ type: "text-start", id: textId });
-              textStarted = true;
-            }
-            enqueueVisualDelta({
-              type: "text-delta",
-              id: textId,
-              delta: event.body,
-            });
-          }
-
-          if (event.type === "reasoning") {
-            finishActiveText();
-            const delta = reasoningContent(event);
-            if (delta && !reasoningStarted) {
-              controller.enqueue({
-                type: "reasoning-start",
-                id: reasoningId,
-              });
-              reasoningStarted = true;
-            }
-            if (delta) {
-              enqueueVisualDelta({
-                type: "reasoning-delta",
-                id: reasoningId,
-                delta,
-              });
-            }
-          }
-
-          if (event.type === "tool_call_chunks") {
-            finishActiveNarrative();
-            for (const chunk of toolCallsFromEvent(event)) {
-              const toolCallId = chunk.id ?? currentToolCallId;
-              if (!toolCallId) continue;
-              currentToolCallId = toolCallId;
-              if (chunk.name && !announcedToolCalls.has(toolCallId)) {
-                toolCallNames.set(toolCallId, chunk.name);
-                controller.enqueue({
-                  type: "tool-input-start",
-                  toolCallId,
-                  toolName: chunk.name,
-                  dynamic: true,
-                });
-                announcedToolCalls.add(toolCallId);
-              }
-              if (typeof chunk.args === "string" && chunk.args) {
-                const previousInput = toolCallInputs.get(toolCallId);
-                toolCallInputs.set(
-                  toolCallId,
-                  `${typeof previousInput === "string" ? previousInput : ""}${
-                    chunk.args
-                  }`
-                );
-                toolInputDeltas.push(toolCallId, chunk.args);
-              }
-            }
-          }
-
-          if (event.type === "tool_calls") {
-            finishActiveNarrative();
-            for (const toolCall of toolCallsFromEvent(event)) {
-              const toolCallId = toolCall.id ?? `tool-${crypto.randomUUID()}`;
-              const toolName = toolCall.name ?? "tool";
-              const toolState = getToolCallState(toolCall);
-              const { invokeStatus, resultStatus } = toolState;
-              const toolInput = parseToolInput(
-                toolCall.args ?? toolCall.input ?? {}
-              );
-              toolCallNames.set(toolCallId, toolName);
-              toolCallInputs.set(toolCallId, toolInput);
-              controller.enqueue({
-                type: "tool-input-available",
-                toolCallId,
-                toolName,
-                input: toolInput,
-                providerMetadata: getToolProviderMetadata(toolCall),
-                dynamic: true,
-              });
-              announcedToolCalls.add(toolCallId);
-
-              if (toolState.failed) {
-                controller.enqueue({
-                  type: "tool-output-error",
-                  toolCallId,
-                  errorText: String(
-                    toolCall.content ?? toolCall.output ?? "Tool call failed"
-                  ),
-                  dynamic: true,
-                });
-              } else if (toolState.completed) {
-                controller.enqueue({
-                  type: "tool-output-available",
-                  toolCallId,
-                  output: toolCall.output ??
-                    toolCall.content ?? {
-                      status: invokeStatus || resultStatus,
-                    },
-                  dynamic: true,
-                });
-              }
-            }
-          }
-
-          if (event.type === "tool_call_status" && isRecord(event.body)) {
-            finishActiveNarrative();
-            const toolCall = isRecord(event.body.toolCall)
-              ? (event.body.toolCall as NocoBaseToolCall)
-              : undefined;
-            const toolCallId = toolCall?.id;
-            if (toolCallId) {
-              const mergedToolCall = {
-                ...toolCall,
-                invokeStatus:
-                  typeof event.body.invokeStatus === "string"
-                    ? event.body.invokeStatus
-                    : toolCall.invokeStatus,
-                status:
-                  typeof event.body.status === "string"
-                    ? event.body.status
-                    : toolCall.status,
-                content: event.body.content ?? toolCall.content,
-              } satisfies NocoBaseToolCall;
-              const toolState = getToolCallState(mergedToolCall);
-              const { invokeStatus, resultStatus } = toolState;
-              const toolName =
-                toolCall.name ?? toolCallNames.get(toolCallId) ?? "tool";
-              const toolInput =
-                toolCall.args !== undefined || toolCall.input !== undefined
-                  ? parseToolInput(toolCall.args ?? toolCall.input)
-                  : parseToolInput(toolCallInputs.get(toolCallId) ?? {});
-              toolCallNames.set(toolCallId, toolName);
-              toolCallInputs.set(toolCallId, toolInput);
-              controller.enqueue({
-                type: "tool-input-available",
-                toolCallId,
-                toolName,
-                input: toolInput,
-                providerMetadata: getToolProviderMetadata(mergedToolCall),
-                dynamic: true,
-              });
-              announcedToolCalls.add(toolCallId);
-              if (toolState.failed) {
-                controller.enqueue({
-                  type: "tool-output-error",
-                  toolCallId,
-                  errorText: String(event.body.content ?? "Tool call failed"),
-                  dynamic: true,
-                });
-              } else if (toolState.completed) {
-                controller.enqueue({
-                  type: "tool-output-available",
-                  toolCallId,
-                  output: event.body.content ?? {
-                    status: invokeStatus || resultStatus,
-                  },
-                  dynamic: true,
-                });
-              }
-            }
-          }
-
-          if (event.type === "error") {
-            controller.enqueue({
-              type: "error",
-              errorText: String(event.body ?? "AI response failed"),
-            });
-          }
-        }
-
-        toolInputDeltas.flushAll();
-        visualDeltas.flushAll();
-        flushSubAgentNarrativeEvents();
-        subAgentToolEvents.flushAll();
-        finishActiveNarrative();
-        controller.enqueue({ type: "finish" });
-        controller.close();
-      } catch (error) {
-        toolInputDeltas.clear();
-        visualDeltas.clear();
-        subAgentNarrativeEvents.clear();
-        subAgentToolEvents.clear();
-        controller.error(error);
-      }
-    },
-  });
-}

package/src/extensions/nocobase-ai/providers/use-automatic-tool-approval.ts

@@ -1,94 +0,0 @@
-import type { Chat } from "@ai-sdk/react";
-import { useCallback, useRef } from "react";
-import { getChatToolParts, getNocoBaseToolMetadata } from "./chat-message-utils";
-import type { AIChatMessage, AIToolCallDecision } from "./types";
-
-const isChatRunning = (chat: Chat<AIChatMessage>) =>
-  chat.status === "streaming" || chat.status === "submitted";
-
-export function useAutomaticToolApproval({
-  enabled,
-  decide,
-}: {
-  enabled: boolean;
-  decide: (
-    conversationId: string,
-    targetChat: Chat<AIChatMessage>,
-    decision: AIToolCallDecision,
-    options?: { automatic?: boolean }
-  ) => Promise<void>;
-}) {
-  const approvedRef = useRef(new Set<string>());
-  const runningRef = useRef(new Set<string>());
-  const rerunRef = useRef(new Set<string>());
-
-  const process = useCallback(
-    async (conversationId: string, targetChat: Chat<AIChatMessage>) => {
-      if (!enabled || isChatRunning(targetChat)) return;
-      if (runningRef.current.has(conversationId)) {
-        rerunRef.current.add(conversationId);
-        return;
-      }
-
-      runningRef.current.add(conversationId);
-      try {
-        do {
-          rerunRef.current.delete(conversationId);
-          const pending = getChatToolParts(targetChat.messages)
-            .filter(
-              ({ part }) => getNocoBaseToolMetadata(part)?.autoApprove === true
-            )
-            .flatMap(({ message, part }) => {
-              const key = `${conversationId}:${message.id}:${part.toolCallId}`;
-              return approvedRef.current.has(key)
-                ? []
-                : [{ key, message, part }];
-            });
-
-          for (const { key, message, part } of pending) {
-            approvedRef.current.add(key);
-            try {
-              await decide(
-                conversationId,
-                targetChat,
-                {
-                  messageId: message.id,
-                  toolCallId: part.toolCallId,
-                  toolName:
-                    part.type === "dynamic-tool"
-                      ? part.toolName
-                      : part.type.slice(5),
-                  decision: "approve",
-                },
-                { automatic: true }
-              );
-            } catch (error) {
-              approvedRef.current.delete(key);
-              throw error;
-            }
-          }
-        } while (rerunRef.current.has(conversationId));
-      } finally {
-        runningRef.current.delete(conversationId);
-        rerunRef.current.delete(conversationId);
-      }
-    },
-    [decide, enabled]
-  );
-
-  const clearConversation = useCallback((conversationId: string) => {
-    for (const key of approvedRef.current) {
-      if (key.startsWith(`${conversationId}:`)) approvedRef.current.delete(key);
-    }
-    runningRef.current.delete(conversationId);
-    rerunRef.current.delete(conversationId);
-  }, []);
-
-  const reset = useCallback(() => {
-    approvedRef.current.clear();
-    runningRef.current.clear();
-    rerunRef.current.clear();
-  }, []);
-
-  return { clearConversation, process, reset };
-}