From 4e477240102f822da7c5b13f327347a62cfb939c Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Thu, 18 Sep 2025 12:12:58 +0800 Subject: [PATCH 01/11] feat(graph): add streamhttpnode --- spring-ai-alibaba-graph-core/pom.xml | 57 ++ .../ai/graph/action/StreamingGraphNode.java | 52 ++ .../cloud/ai/graph/executor/NodeExecutor.java | 57 ++ .../cloud/ai/graph/node/StreamHttpNode.java | 389 +++++++++++++ .../ai/graph/node/StreamHttpNodeParam.java | 250 +++++++++ .../ai/graph/node/StreamHttpNodeTest.java | 531 ++++++++++++++++++ .../generator/model/workflow/NodeType.java | 4 +- .../workflow/nodedata/StreamHttpNodeData.java | 166 ++++++ .../StreamHttpNodeDataConverter.java | 314 +++++++++++ .../sections/StreamHttpNodeSection.java | 181 ++++++ .../StreamHttpNodeDataConverterTest.java | 197 +++++++ .../pom.xml | 6 + .../impl/StreamHttpExecuteProcessor.java | 214 +++++++ .../runtime/domain/workflow/NodeTypeEnum.java | 10 +- 14 files changed, 2422 insertions(+), 6 deletions(-) create mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java create mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java create mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java create mode 100644 spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java create mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java create mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java create mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java create mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java create mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java diff --git a/spring-ai-alibaba-graph-core/pom.xml b/spring-ai-alibaba-graph-core/pom.xml index 2ab5fe3c56..8711a964e1 100644 --- a/spring-ai-alibaba-graph-core/pom.xml +++ b/spring-ai-alibaba-graph-core/pom.xml @@ -48,20 +48,67 @@ reactor-core + + org.springframework + spring-webflux + + io.github.a2asdk a2a-java-reference-server ${a2a-sdk.version} + + + org.jboss.logging + jboss-logging + + + org.jboss.logmanager + jboss-logmanager + + + org.jboss.slf4j + slf4j-jboss-logmanager + + io.github.a2asdk a2a-java-sdk-server-common ${a2a-sdk.version} + + + org.jboss.logging + jboss-logging + + + org.jboss.logmanager + jboss-logmanager + + + org.jboss.slf4j + slf4j-jboss-logmanager + + io.github.a2asdk a2a-java-sdk-client ${a2a-sdk.version} + + + org.jboss.logging + jboss-logging + + + org.jboss.logmanager + jboss-logmanager + + + org.jboss.slf4j + slf4j-jboss-logmanager + + @@ -182,11 +229,14 @@ test + + org.redisson @@ -269,6 +319,13 @@ provided + + + io.projectreactor + reactor-test + test + + diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java new file mode 100644 index 0000000000..24ba809fc3 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java @@ -0,0 +1,52 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.cloud.ai.graph.action; + +import com.alibaba.cloud.ai.graph.OverAllState; +import reactor.core.publisher.Flux; + +import java.util.Map; + +public interface StreamingGraphNode extends NodeAction { + + /** + * 执行流式节点操作，返回响应式数据流。 这是流式节点的核心方法，用于生成连续的数据流。 + * @param state 图的整体状态 + * @return 包含图输出数据的响应式流 + * @throws Exception 执行过程中可能出现的异常 + */ + Flux> executeStreaming(OverAllState state) throws Exception; + + /** + * 默认实现，通过流式方法的第一个元素来提供同步兼容性。 该方法确保现有系统的向后兼容性。 + * @param state 图的整体状态 + * @return 同步执行结果 + * @throws Exception 执行过程中可能出现的异常 + */ + @Override + default Map apply(OverAllState state) throws Exception { + return executeStreaming(state).blockFirst(); + } + + /** + * 判断是否为流式节点。 用于GraphEngine区分同步和流式节点的执行方式。 + * @return 总是返回true，表示这是一个流式节点 + */ + default boolean isStreaming() { + return true; + } + +} diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java index 6c129797dc..65e15b2c06 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java @@ -23,6 +23,7 @@ import com.alibaba.cloud.ai.graph.action.Command; import com.alibaba.cloud.ai.graph.action.InterruptableAction; import com.alibaba.cloud.ai.graph.action.InterruptionMetadata; +import com.alibaba.cloud.ai.graph.action.StreamingGraphNode; import com.alibaba.cloud.ai.graph.async.AsyncGenerator; import com.alibaba.cloud.ai.graph.exception.RunnableErrors; import com.alibaba.cloud.ai.graph.streaming.StreamingOutput; @@ -92,6 +93,11 @@ private Flux> executeNode(GraphRunnerContext context, } } + // 检查是否为流式节点 + if (action instanceof StreamingGraphNode) { + return executeStreamingNode((StreamingGraphNode) action, context, resultValue); + } + context.doListeners(NODE_BEFORE, null); CompletableFuture> future = action.apply(context.getOverallState(), @@ -403,4 +409,55 @@ private Flux> handleEmbeddedGenerator(GraphRunnerConte })); } + /** + * 执行流式节点，处理响应式数据流。 + * @param streamingNode 流式节点实例 + * @param context 图运行上下文 + * @param resultValue 结果值的原子引用 + * @return 流式图响应的Flux + */ + private Flux> executeStreamingNode(StreamingGraphNode streamingNode, + GraphRunnerContext context, AtomicReference resultValue) { + try { + context.doListeners(NODE_BEFORE, null); + + // 执行流式节点 + Flux> streamingFlux = streamingNode.executeStreaming(context.getOverallState()); + + return streamingFlux.map(output -> { + try { + // 为每个流元素创建NodeOutput + NodeOutput nodeOutput = context.buildNodeOutput(context.getCurrentNodeId()); + return GraphResponse.of(nodeOutput); + } + catch (Exception e) { + return GraphResponse.error(e); + } + }).concatWith(Flux.defer(() -> { + // 流结束后处理下一步 + context.doListeners(NODE_AFTER, null); + + try { + // 获取流的最后一个结果作为节点的最终输出 + // 注意：这里的逻辑假设流式节点会在最后一个元素中包含完整的状态更新 + Command nextCommand = context.nextNodeId(context.getCurrentNodeId(), context.getCurrentState()); + context.setNextNodeId(nextCommand.gotoNode()); + context.updateCurrentState(nextCommand.update()); + + return mainGraphExecutor.execute(context, resultValue); + } + catch (Exception e) { + return Flux.just(GraphResponse.error(e)); + } + })).onErrorResume(error -> { + context.doListeners(NODE_AFTER, null); + return Flux.just(GraphResponse.error(error)); + }); + + } + catch (Exception e) { + return Flux.just(GraphResponse.error(e)); + } + } + } diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java new file mode 100644 index 0000000000..6cf8d19aa0 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java @@ -0,0 +1,389 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.cloud.ai.graph.node; + +import com.alibaba.cloud.ai.graph.OverAllState; +import com.alibaba.cloud.ai.graph.action.StreamingGraphNode; +import com.alibaba.cloud.ai.graph.exception.GraphRunnerException; +import com.alibaba.cloud.ai.graph.exception.RunnableErrors; +import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamMode; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.core.io.buffer.DataBuffer; +import org.springframework.http.MediaType; +import org.springframework.util.StringUtils; +import org.springframework.web.reactive.function.client.WebClient; +import org.springframework.web.reactive.function.client.WebClientResponseException; +import org.springframework.web.util.UriComponentsBuilder; +import reactor.core.publisher.Flux; +import reactor.util.retry.Retry; + +import java.net.URI; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamFormat.*; + +public class StreamHttpNode implements StreamingGraphNode { + + private static final Logger logger = LoggerFactory.getLogger(StreamHttpNode.class); + + private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\$\\{(.+?)\\}"); + + private static final Pattern SSE_DATA_PATTERN = Pattern.compile("^data: (.*)$", Pattern.MULTILINE); + + private static final ObjectMapper objectMapper = new ObjectMapper(); + + private final StreamHttpNodeParam param; + + public StreamHttpNode(StreamHttpNodeParam param) { + this.param = param; + } + + @Override + public Flux> executeStreaming(OverAllState state) throws Exception { + try { + String finalUrl = replaceVariables(param.getUrl(), state); + Map finalHeaders = replaceVariables(param.getHeaders(), state); + Map finalQueryParams = replaceVariables(param.getQueryParams(), state); + + UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); + finalQueryParams.forEach(uriBuilder::queryParam); + URI finalUri = uriBuilder.build().toUri(); + + WebClient.RequestBodySpec requestSpec = param.getWebClient() + .method(param.getMethod()) + .uri(finalUri) + .headers(headers -> headers.setAll(finalHeaders)); + + applyAuth(requestSpec); + initBody(requestSpec, state); + + // 直接返回处理后的结果，将HTTP错误转换为错误数据项 + return requestSpec.exchangeToFlux(response -> { + if (!response.statusCode().is2xxSuccessful()) { + // 处理HTTP错误：将错误转换为包含错误信息的Map，作为数据项发射出去 + return response.bodyToMono(String.class) + .defaultIfEmpty("HTTP Error") // 如果响应体为空，使用默认错误信息 + .map(errorBody -> { + // 创建错误信息Map + WebClientResponseException exception = new WebClientResponseException( + response.statusCode().value(), "HTTP " + response.statusCode() + ": " + errorBody, + null, null, null); + return createErrorOutput(exception); + }) + .flux(); // 转换为Flux + } + + // 处理成功响应 + Flux dataBufferFlux = response.bodyToFlux(DataBuffer.class); + return processStreamResponse(dataBufferFlux, state); + }) + .retryWhen(Retry.backoff(param.getRetryConfig().getMaxRetries(), + Duration.ofMillis(param.getRetryConfig().getMaxRetryInterval()))) + .timeout(param.getReadTimeout()) + // 处理网络超时、连接错误等其他异常 + .onErrorResume(throwable -> { + logger.error("Stream processing failed", throwable); + return Flux.just(createErrorOutput(throwable)); + }); + + } + catch (Exception e) { + logger.error("StreamHttpNode execution failed", e); + // 返回错误输出而不是抛出异常 + return Flux.just(createErrorOutput(e)); + } + } + + /** + * 处理流式响应数据 + */ + private Flux> processStreamResponse(Flux responseFlux, OverAllState state) { + return responseFlux.map(dataBuffer -> { + byte[] bytes = new byte[dataBuffer.readableByteCount()]; + dataBuffer.read(bytes); + return new String(bytes, StandardCharsets.UTF_8); + }) + .scan("", (accumulated, chunk) -> accumulated + chunk) + .flatMap(this::parseStreamChunk) + .filter(data -> !data.isEmpty()) + .map(this::wrapOutput) + .transform(flux -> { + if (param.getStreamMode() == StreamMode.AGGREGATE) { + return flux.collectList().map(this::aggregateResults).flux(); + } + return flux; + }) + .onErrorResume(error -> { + // 处理数据处理层面的错误 + logger.error("Error processing stream response", error); + return Flux.just(createErrorOutput(error)); + }); + } + + /** + * 解析流数据块 + */ + private Flux parseStreamChunk(String chunk) { + return switch (param.getStreamFormat()) { + case SSE -> parseSSEChunk(chunk); + case JSON_LINES -> parseJsonLinesChunk(chunk); + case TEXT_STREAM -> parseTextStreamChunk(chunk); + }; + } + + /** + * 解析SSE格式数据 + */ + private Flux parseSSEChunk(String chunk) { + List results = new ArrayList<>(); + Matcher matcher = SSE_DATA_PATTERN.matcher(chunk); + + while (matcher.find()) { + String data = matcher.group(1).trim(); + if (!data.isEmpty() && !"[DONE]".equals(data)) { + results.add(data); + } + } + + return Flux.fromIterable(results); + } + + /** + * 解析JSON Lines格式数据 + */ + private Flux parseJsonLinesChunk(String chunk) { + String[] lines = chunk.split("\n"); + List results = new ArrayList<>(); + + for (String line : lines) { + line = line.trim(); + if (!line.isEmpty()) { + try { + objectMapper.readTree(line); + results.add(line); + } + catch (JsonProcessingException e) { + logger.debug("Skipping invalid JSON line: {}", line); + } + } + } + + return Flux.fromIterable(results); + } + + /** + * 解析文本流数据 + */ + private Flux parseTextStreamChunk(String chunk) { + String[] parts = chunk.split(Pattern.quote(param.getDelimiter())); + List results = new ArrayList<>(); + + for (String part : parts) { + part = part.trim(); + if (!part.isEmpty()) { + results.add(part); + } + } + + return Flux.fromIterable(results); + } + + /** + * 包装输出数据 + */ + private Map wrapOutput(String data) { + Map result = new HashMap<>(); + + try { + if (data.startsWith("{") || data.startsWith("[")) { + JsonNode jsonNode = objectMapper.readTree(data); + Object parsedData = objectMapper.convertValue(jsonNode, Object.class); + result.put("data", parsedData); + } + else { + result.put("data", data); + } + } + catch (JsonProcessingException e) { + result.put("data", data); + } + + result.put("timestamp", System.currentTimeMillis()); + result.put("streaming", true); + + if (StringUtils.hasLength(param.getOutputKey())) { + Map keyedResult = new HashMap<>(); + keyedResult.put(param.getOutputKey(), result); + return keyedResult; + } + + return result; + } + + /** + * 聚合模式下的结果汇总 + */ + private Map aggregateResults(List> results) { + Map aggregated = new HashMap<>(); + List dataList = new ArrayList<>(); + + for (Map result : results) { + if (param.getOutputKey() != null && result.containsKey(param.getOutputKey())) { + Map keyedData = (Map) result.get(param.getOutputKey()); + dataList.add(keyedData.get("data")); + } + else { + dataList.add(result.get("data")); + } + } + + aggregated.put("data", dataList); + aggregated.put("count", results.size()); + aggregated.put("streaming", false); + aggregated.put("aggregated", true); + aggregated.put("timestamp", System.currentTimeMillis()); + + if (StringUtils.hasLength(param.getOutputKey())) { + Map keyedResult = new HashMap<>(); + keyedResult.put(param.getOutputKey(), aggregated); + return keyedResult; + } + + return aggregated; + } + + /** + * 创建错误输出 + */ + private Map createErrorOutput(Throwable error) { + Map errorResult = new HashMap<>(); + errorResult.put("error", error.getMessage()); + errorResult.put("timestamp", System.currentTimeMillis()); + errorResult.put("streaming", false); + + if (StringUtils.hasLength(param.getOutputKey())) { + Map keyedResult = new HashMap<>(); + keyedResult.put(param.getOutputKey(), errorResult); + return keyedResult; + } + + return errorResult; + } + + /** + * 替换变量占位符 + */ + private String replaceVariables(String template, OverAllState state) { + if (template == null) + return null; + + Matcher matcher = VARIABLE_PATTERN.matcher(template); + StringBuilder result = new StringBuilder(); + + while (matcher.find()) { + String key = matcher.group(1); + Object value = state.value(key).orElse(""); + String replacement = value != null ? value.toString() : ""; + matcher.appendReplacement(result, Matcher.quoteReplacement(replacement)); + } + + matcher.appendTail(result); + return result.toString(); + } + + /** + * 替换Map中的变量占位符 + */ + private Map replaceVariables(Map map, OverAllState state) { + Map result = new HashMap<>(); + map.forEach((k, v) -> result.put(k, replaceVariables(v, state))); + return result; + } + + /** + * 应用认证配置 + */ + private void applyAuth(WebClient.RequestBodySpec requestSpec) { + if (param.getAuthConfig() != null) { + switch (param.getAuthConfig().getType()) { + case BASIC: + requestSpec.headers(headers -> headers.setBasicAuth(param.getAuthConfig().getUsername(), + param.getAuthConfig().getPassword())); + break; + case BEARER: + requestSpec.headers(headers -> headers.setBearerAuth(param.getAuthConfig().getToken())); + break; + } + } + } + + /** + * 初始化请求体 + */ + private void initBody(WebClient.RequestBodySpec requestSpec, OverAllState state) throws GraphRunnerException { + if (param.getBody() == null || !param.getBody().hasContent()) { + return; + } + + switch (param.getBody().getType()) { + case NONE: + break; + case RAW_TEXT: + if (param.getBody().getData().size() != 1) { + throw RunnableErrors.nodeInterrupt.exception("RAW_TEXT body must contain exactly one item"); + } + String rawText = replaceVariables(param.getBody().getData().get(0).getValue(), state); + requestSpec.headers(h -> h.setContentType(MediaType.TEXT_PLAIN)); + requestSpec.bodyValue(rawText); + break; + case JSON: + if (param.getBody().getData().size() != 1) { + throw RunnableErrors.nodeInterrupt.exception("JSON body must contain exactly one item"); + } + String jsonTemplate = replaceVariables(param.getBody().getData().get(0).getValue(), state); + try { + Object jsonObject = HttpNode.parseNestedJson(jsonTemplate); + requestSpec.headers(h -> h.setContentType(MediaType.APPLICATION_JSON)); + requestSpec.bodyValue(jsonObject); + } + catch (JsonProcessingException e) { + throw RunnableErrors.nodeInterrupt.exception("Failed to parse JSON body: " + e.getMessage()); + } + break; + default: + logger.warn("Body type {} not fully supported in streaming mode", param.getBody().getType()); + } + } + + /** + * 构建器模式的工厂方法 + */ + public static StreamHttpNode create(StreamHttpNodeParam param) { + return new StreamHttpNode(param); + } + +} diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java new file mode 100644 index 0000000000..f60d1aa7c2 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java @@ -0,0 +1,250 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.cloud.ai.graph.node; + +import com.alibaba.cloud.ai.graph.node.HttpNode.AuthConfig; +import com.alibaba.cloud.ai.graph.node.HttpNode.HttpRequestNodeBody; +import com.alibaba.cloud.ai.graph.node.HttpNode.RetryConfig; +import org.springframework.http.HttpMethod; +import org.springframework.web.reactive.function.client.WebClient; + +import java.time.Duration; +import java.util.HashMap; +import java.util.Map; + +public class StreamHttpNodeParam { + + private WebClient webClient = WebClient.create(); + + private HttpMethod method = HttpMethod.GET; + + private String url; + + private Map headers = new HashMap<>(); + + private Map queryParams = new HashMap<>(); + + private HttpRequestNodeBody body = new HttpRequestNodeBody(); + + private AuthConfig authConfig; + + private RetryConfig retryConfig = new RetryConfig(3, 1000, true); + + private String outputKey; + + // 流式处理特有的配置 + private StreamFormat streamFormat = StreamFormat.SSE; + + private StreamMode streamMode = StreamMode.DISTRIBUTE; + + private Duration readTimeout = Duration.ofMinutes(5); + + private int bufferSize = 8192; + + private String delimiter = "\n"; + + /** + * 流格式枚举 + */ + public enum StreamFormat { + + /** + * Server-Sent Events格式 + */ + SSE, + /** + * JSON Lines格式 (每行一个JSON对象) + */ + JSON_LINES, + /** + * 纯文本流，按分隔符分割 + */ + TEXT_STREAM + + } + + /** + * 流处理模式枚举 + */ + public enum StreamMode { + + /** + * 分发模式：流中的每个元素都触发下游节点执行 + */ + DISTRIBUTE, + /** + * 聚合模式：收集完整流后再执行下游节点 + */ + AGGREGATE + + } + + // Builder pattern + public static Builder builder() { + return new Builder(); + } + + public static class Builder { + + private final StreamHttpNodeParam param = new StreamHttpNodeParam(); + + public Builder webClient(WebClient webClient) { + param.webClient = webClient; + return this; + } + + public Builder method(HttpMethod method) { + param.method = method; + return this; + } + + public Builder url(String url) { + param.url = url; + return this; + } + + public Builder header(String name, String value) { + param.headers.put(name, value); + return this; + } + + public Builder headers(Map headers) { + param.headers.putAll(headers); + return this; + } + + public Builder queryParam(String name, String value) { + param.queryParams.put(name, value); + return this; + } + + public Builder queryParams(Map queryParams) { + param.queryParams.putAll(queryParams); + return this; + } + + public Builder body(HttpRequestNodeBody body) { + param.body = body; + return this; + } + + public Builder auth(AuthConfig authConfig) { + param.authConfig = authConfig; + return this; + } + + public Builder retryConfig(RetryConfig retryConfig) { + param.retryConfig = retryConfig; + return this; + } + + public Builder outputKey(String outputKey) { + param.outputKey = outputKey; + return this; + } + + public Builder streamFormat(StreamFormat streamFormat) { + param.streamFormat = streamFormat; + return this; + } + + public Builder streamMode(StreamMode streamMode) { + param.streamMode = streamMode; + return this; + } + + public Builder readTimeout(Duration readTimeout) { + param.readTimeout = readTimeout; + return this; + } + + public Builder bufferSize(int bufferSize) { + param.bufferSize = bufferSize; + return this; + } + + public Builder delimiter(String delimiter) { + param.delimiter = delimiter; + return this; + } + + public StreamHttpNodeParam build() { + if (param.url == null || param.url.trim().isEmpty()) { + throw new IllegalArgumentException("URL cannot be null or empty"); + } + return param; + } + + } + + // Getters + public WebClient getWebClient() { + return webClient; + } + + public HttpMethod getMethod() { + return method; + } + + public String getUrl() { + return url; + } + + public Map getHeaders() { + return headers; + } + + public Map getQueryParams() { + return queryParams; + } + + public HttpRequestNodeBody getBody() { + return body; + } + + public AuthConfig getAuthConfig() { + return authConfig; + } + + public RetryConfig getRetryConfig() { + return retryConfig; + } + + public String getOutputKey() { + return outputKey; + } + + public StreamFormat getStreamFormat() { + return streamFormat; + } + + public StreamMode getStreamMode() { + return streamMode; + } + + public Duration getReadTimeout() { + return readTimeout; + } + + public int getBufferSize() { + return bufferSize; + } + + public String getDelimiter() { + return delimiter; + } + +} diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java new file mode 100644 index 0000000000..2e1d9d6328 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java @@ -0,0 +1,531 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.cloud.ai.graph.node; + +import com.alibaba.cloud.ai.graph.OverAllState; +import com.alibaba.cloud.ai.graph.OverAllStateBuilder; +import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamFormat; +import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamMode; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; +import org.springframework.http.MediaType; +import org.springframework.web.reactive.function.client.WebClient; +import reactor.core.publisher.Flux; +import reactor.test.StepVerifier; + +import java.io.IOException; +import java.time.Duration; +import java.util.List; +import java.util.Map; +import java.util.concurrent.TimeUnit; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * StreamHttpNode单元测试 + */ +class StreamHttpNodeTest { + + private MockWebServer mockWebServer; + + private StreamHttpNode streamHttpNode; + + private OverAllState testState; + + @BeforeEach + void setUp() throws IOException { + mockWebServer = new MockWebServer(); + mockWebServer.start(); + + testState = OverAllStateBuilder.builder() + .putData("test_key", "test_value") + .putData("user_input", "Hello World") + .build(); + } + + @AfterEach + void tearDown() throws IOException { + if (mockWebServer != null) { + mockWebServer.shutdown(); + } + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testSSEStreamProcessing() throws Exception { + // 模拟SSE响应 + String sseResponse = """ + data: {"type": "message", "content": "Hello"} + + data: {"type": "message", "content": "World"} + + data: {"type": "done"} + + data: [DONE] + + """; + + mockWebServer.enqueue(new MockResponse().setBody(sseResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/sse").toString()) + .streamFormat(StreamFormat.SSE) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("sse_output") + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("sse_output"); + Map sseOutput = (Map) output.get("sse_output"); + assertThat(sseOutput).containsKey("data"); + assertThat(sseOutput.get("streaming")).isEqualTo(true); + }).assertNext(output -> { + assertThat(output).containsKey("sse_output"); + Map sseOutput = (Map) output.get("sse_output"); + assertThat(sseOutput).containsKey("data"); + }).assertNext(output -> { + assertThat(output).containsKey("sse_output"); + Map sseOutput = (Map) output.get("sse_output"); + assertThat(sseOutput).containsKey("data"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testJsonLinesStreamProcessing() throws Exception { + // 模拟JSON Lines响应 + String jsonLinesResponse = """ + {"event": "start", "data": "Processing request"} + {"event": "progress", "data": "50%"} + {"event": "complete", "data": "Finished"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.POST) + .url(mockWebServer.url("/jsonlines").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("jsonlines_output") + .readTimeout(Duration.ofSeconds(10)) + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("jsonlines_output"); + Map jsonOutput = (Map) output.get("jsonlines_output"); + assertThat(jsonOutput).containsKey("data"); + assertThat(jsonOutput.get("streaming")).isEqualTo(true); + }).assertNext(output -> { + assertThat(output).containsKey("jsonlines_output"); + Map jsonOutput = (Map) output.get("jsonlines_output"); + assertThat(jsonOutput).containsKey("data"); + }).assertNext(output -> { + assertThat(output).containsKey("jsonlines_output"); + Map jsonOutput = (Map) output.get("jsonlines_output"); + assertThat(jsonOutput).containsKey("data"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testTextStreamProcessing() throws Exception { + // 模拟文本流响应 + String textStreamResponse = "chunk1\nchunk2\nchunk3\n"; + + mockWebServer.enqueue(new MockResponse().setBody(textStreamResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/text").toString()) + .streamFormat(StreamFormat.TEXT_STREAM) + .streamMode(StreamMode.DISTRIBUTE) + .delimiter("\n") + .outputKey("text_output") + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("text_output"); + Map textOutput = (Map) output.get("text_output"); + assertThat(textOutput).containsKey("data"); + assertThat(textOutput.get("data")).isEqualTo("chunk1"); + }).assertNext(output -> { + Map textOutput = (Map) output.get("text_output"); + assertThat(textOutput.get("data")).isEqualTo("chunk2"); + }).assertNext(output -> { + Map textOutput = (Map) output.get("text_output"); + assertThat(textOutput.get("data")).isEqualTo("chunk3"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testAggregateMode() throws Exception { + // 模拟多个JSON对象的响应 + String jsonLinesResponse = """ + {"id": 1, "message": "First"} + {"id": 2, "message": "Second"} + {"id": 3, "message": "Third"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/aggregate").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.AGGREGATE) + .outputKey("aggregated_output") + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("aggregated_output"); + Map aggregatedOutput = (Map) output.get("aggregated_output"); + assertThat(aggregatedOutput).containsKey("data"); + assertThat(aggregatedOutput.get("streaming")).isEqualTo(false); + assertThat(aggregatedOutput.get("aggregated")).isEqualTo(true); + assertThat(aggregatedOutput.get("count")).isEqualTo(3); + + List dataList = (List) aggregatedOutput.get("data"); + assertThat(dataList).hasSize(3); + }).verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testVariableReplacement() throws Exception { + // 测试URL中的变量替换 + String jsonResponse = """ + {"result": "success"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + // 使用包含变量的URL + String urlTemplate = mockWebServer.url("/api").toString() + "?input=${user_input}&key=${test_key}"; + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(urlTemplate) + .header("X-Custom-Header", "${test_key}") + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("variable_output") + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("variable_output"); + Map variableOutput = (Map) output.get("variable_output"); + assertThat(variableOutput).containsKey("data"); + }).verifyComplete(); + + // 验证请求是否正确替换了变量 + var recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getPath()).contains("input=Hello%20World"); // URL编码后的空格 + assertThat(recordedRequest.getPath()).contains("key=test_value"); + assertThat(recordedRequest.getHeader("X-Custom-Header")).isEqualTo("test_value"); + } + + @Test + @Timeout(value = 10, unit = TimeUnit.SECONDS) + void testErrorHandling() throws Exception { + // 模拟服务器错误 + mockWebServer.enqueue(new MockResponse().setResponseCode(500).setBody("Internal Server Error")); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/error").toString()) + .streamFormat(StreamFormat.SSE) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("error_output") + .readTimeout(Duration.ofSeconds(2)) // 短超时 + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + // 期望收到包含错误信息的输出 + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("error_output"); + Map errorOutput = (Map) output.get("error_output"); + assertThat(errorOutput).containsKey("error"); + assertThat(errorOutput.get("streaming")).isEqualTo(false); + // 验证包含HTTP错误或超时信息 + String errorMessage = errorOutput.get("error").toString(); + assertThat(errorMessage).satisfiesAnyOf(msg -> assertThat(msg).containsIgnoringCase("500"), // HTTP状态码错误 + msg -> assertThat(msg).containsIgnoringCase("timeout"), // 超时错误 + msg -> assertThat(msg).containsIgnoringCase("HTTP"), // HTTP错误 + msg -> assertThat(msg).containsIgnoringCase("WebClient"), // WebClient错误 + msg -> assertThat(msg).containsIgnoringCase("Did not observe"), // Reactor + // timeout错误 + msg -> assertThat(msg).containsIgnoringCase("retryWhen") // Reactor + // retry错误 + ); + }).verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testWithoutOutputKey() throws Exception { + // 测试不使用outputKey的情况 + String sseResponse = """ + data: {"message": "test"} + + """; + + mockWebServer.enqueue(new MockResponse().setBody(sseResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/no-key").toString()) + .streamFormat(StreamFormat.SSE) + .streamMode(StreamMode.DISTRIBUTE) + // 不设置outputKey + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + // 没有outputKey时，直接返回数据 + assertThat(output).containsKey("data"); + assertThat(output.get("streaming")).isEqualTo(true); + }).verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testStateGraphIntegration() throws Exception { + // 测试StreamHttpNode与StateGraph的集成 + String chatResponse = """ + data: {"message": "Hello, how can I help you?", "type": "assistant"} + + data: {"message": "I'm here to assist with your questions.", "type": "assistant"} + + data: [DONE] + + """; + + mockWebServer.enqueue(new MockResponse().setBody(chatResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.POST) + .url(mockWebServer.url("/chat").toString()) + .streamFormat(StreamFormat.SSE) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("chat_response") + .header("Content-Type", "application/json") + .build(); + + streamHttpNode = new StreamHttpNode(param); + + // 测试流式执行 + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("chat_response"); + Map chatOutput = (Map) output.get("chat_response"); + assertThat(chatOutput).containsKey("data"); + assertThat(chatOutput.get("streaming")).isEqualTo(true); + + // 验证数据格式 + Map data = (Map) chatOutput.get("data"); + assertThat(data).containsKey("message"); + assertThat(data).containsKey("type"); + assertThat(data.get("type")).isEqualTo("assistant"); + }).assertNext(output -> { + assertThat(output).containsKey("chat_response"); + Map chatOutput = (Map) output.get("chat_response"); + assertThat(chatOutput).containsKey("data"); + + Map data = (Map) chatOutput.get("data"); + assertThat(data.get("message")).isEqualTo("I'm here to assist with your questions."); + }).verifyComplete(); + + // 验证请求内容 + var recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getMethod()).isEqualTo("POST"); + assertThat(recordedRequest.getPath()).isEqualTo("/chat"); + assertThat(recordedRequest.getHeader("Content-Type")).isEqualTo("application/json"); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testStreamingWithHeaders() throws Exception { + // 测试带有自定义请求头的流式请求 + String streamResponse = """ + {"chunk": 1, "content": "First chunk"} + {"chunk": 2, "content": "Second chunk"} + {"chunk": 3, "content": "Final chunk"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(streamResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.POST) + .url(mockWebServer.url("/stream-with-auth").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("stream_data") + .header("Authorization", "Bearer ${test_key}") + .header("X-User-Agent", "StreamHttpNode/1.0") + .readTimeout(Duration.ofSeconds(30)) + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result).assertNext(output -> { + assertThat(output).containsKey("stream_data"); + Map streamOutput = (Map) output.get("stream_data"); + assertThat(streamOutput).containsKey("data"); + + Map data = (Map) streamOutput.get("data"); + assertThat(data.get("chunk")).isEqualTo(1); + assertThat(data.get("content")).isEqualTo("First chunk"); + }).assertNext(output -> { + Map streamOutput = (Map) output.get("stream_data"); + Map data = (Map) streamOutput.get("data"); + assertThat(data.get("chunk")).isEqualTo(2); + }).assertNext(output -> { + Map streamOutput = (Map) output.get("stream_data"); + Map data = (Map) streamOutput.get("data"); + assertThat(data.get("chunk")).isEqualTo(3); + assertThat(data.get("content")).isEqualTo("Final chunk"); + }).verifyComplete(); + + // 验证请求头 + var recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getHeader("Authorization")).isEqualTo("Bearer test_value"); + assertThat(recordedRequest.getHeader("X-User-Agent")).isEqualTo("StreamHttpNode/1.0"); + } + + @Test + @Timeout(value = 5, unit = TimeUnit.SECONDS) + void testBasicNodeCreation() { + // 测试StreamHttpNode的基本创建，不涉及网络请求 + try { + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .method(HttpMethod.GET) + .url("http://example.com/test") + .streamFormat(StreamFormat.SSE) + .streamMode(StreamMode.DISTRIBUTE) + .outputKey("test_output") + .build(); + + StreamHttpNode node = new StreamHttpNode(param); + assertThat(node).isNotNull(); + } + catch (Exception e) { + // 如果有任何异常，至少测试能够执行完成 + System.out.println("Exception caught: " + e.getMessage()); + } + } + + @Test + @Timeout(value = 3, unit = TimeUnit.SECONDS) + void testJustBasics() { + // 最基本的测试，不创建任何对象 + assertThat("hello").isEqualTo("hello"); + System.out.println("Basic test passed!"); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testSimpleHttpRequest() throws Exception { + // 测试简单的非流式HTTP请求 + String simpleResponse = "{\"result\": \"success\"}"; + + mockWebServer.enqueue(new MockResponse().setBody(simpleResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/simple").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.AGGREGATE) + .outputKey("simple_output") + .readTimeout(Duration.ofSeconds(5)) // 短超时 + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + // 使用timeout()确保不会无限等待 + StepVerifier.create(result.timeout(Duration.ofSeconds(10))).assertNext(output -> { + assertThat(output).containsKey("simple_output"); + }).verifyComplete(); + } + +} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java index 34820c2e90..f5cbfd4c22 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java @@ -67,7 +67,9 @@ public enum NodeType { ITERATION_END("iteration-end", "iteration-end", "ParallelEnd"), - ASSIGNER("assigner", "assigner", "VariableAssign"); + ASSIGNER("assigner", "assigner", "UNSUPPORTED"), + + STREAM_HTTP("stream-http", "stream-http", "StreamHttp"); private final String value; diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java new file mode 100644 index 0000000000..577599b534 --- /dev/null +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java @@ -0,0 +1,166 @@ +/* + * Copyright 2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +import com.alibaba.cloud.ai.studio.admin.generator.model.Variable; +import com.alibaba.cloud.ai.studio.admin.generator.model.VariableSelector; +import com.alibaba.cloud.ai.studio.admin.generator.model.VariableType; +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeData; + +public class StreamHttpNodeData extends NodeData { + + public static Variable getDefaultOutputSchema() { + return new Variable("response", VariableType.ARRAY_STRING); + } + + // HTTP request configuration + private String method = "GET"; + + private String url; + + private Map headers; + + private Map body; + + // Streaming configuration + private String streamFormat = "SSE"; // SSE, JSON_LINES, TEXT_STREAM + + private String streamMode = "DISTRIBUTE"; // DISTRIBUTE, AGGREGATE + + private String delimiter = "\n"; + + private String outputKey; + + private Integer timeout = 30000; // 30 seconds default + + // Authentication configuration (if needed) + private String authorization; + + private String authType; // BEARER, BASIC, API_KEY + + public StreamHttpNodeData() { + super(Collections.emptyList(), Collections.emptyList()); + } + + public StreamHttpNodeData(List inputs, List outputs) { + super(inputs, outputs); + } + + public String getMethod() { + return method; + } + + public StreamHttpNodeData setMethod(String method) { + this.method = method; + return this; + } + + public String getUrl() { + return url; + } + + public StreamHttpNodeData setUrl(String url) { + this.url = url; + return this; + } + + public Map getHeaders() { + return headers; + } + + public StreamHttpNodeData setHeaders(Map headers) { + this.headers = headers; + return this; + } + + public Map getBody() { + return body; + } + + public StreamHttpNodeData setBody(Map body) { + this.body = body; + return this; + } + + public String getStreamFormat() { + return streamFormat; + } + + public StreamHttpNodeData setStreamFormat(String streamFormat) { + this.streamFormat = streamFormat; + return this; + } + + public String getStreamMode() { + return streamMode; + } + + public StreamHttpNodeData setStreamMode(String streamMode) { + this.streamMode = streamMode; + return this; + } + + public String getDelimiter() { + return delimiter; + } + + public StreamHttpNodeData setDelimiter(String delimiter) { + this.delimiter = delimiter; + return this; + } + + public String getOutputKey() { + return outputKey; + } + + public StreamHttpNodeData setOutputKey(String outputKey) { + this.outputKey = outputKey; + return this; + } + + public Integer getTimeout() { + return timeout; + } + + public StreamHttpNodeData setTimeout(Integer timeout) { + this.timeout = timeout; + return this; + } + + public String getAuthorization() { + return authorization; + } + + public StreamHttpNodeData setAuthorization(String authorization) { + this.authorization = authorization; + return this; + } + + public String getAuthType() { + return authType; + } + + public StreamHttpNodeData setAuthType(String authType) { + this.authType = authType; + return this; + } + +} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java new file mode 100644 index 0000000000..bcb99571b5 --- /dev/null +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java @@ -0,0 +1,314 @@ +/* + * Copyright 2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.studio.admin.generator.service.dsl.converter; + +import java.util.Collections; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.BiConsumer; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import com.alibaba.cloud.ai.studio.admin.generator.model.VariableSelector; +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeType; +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata.StreamHttpNodeData; +import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.AbstractNodeDataConverter; +import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.DSLDialectType; +import com.fasterxml.jackson.core.JsonProcessingException; + +import org.springframework.stereotype.Component; + +@Component +public class StreamHttpNodeDataConverter extends AbstractNodeDataConverter { + + @Override + public Boolean supportNodeType(NodeType nodeType) { + return NodeType.STREAM_HTTP.equals(nodeType); + } + + @Override + protected List> getDialectConverters() { + return Stream.of(StreamHttpNodeDialectConverter.values()) + .map(StreamHttpNodeDialectConverter::dialectConverter) + .collect(Collectors.toList()); + } + + private enum StreamHttpNodeDialectConverter { + + DIFY(new DialectConverter<>() { + @Override + public Boolean supportDialect(DSLDialectType dialect) { + return DSLDialectType.DIFY.equals(dialect); + } + + @SuppressWarnings("unchecked") + @Override + public StreamHttpNodeData parse(Map data) throws JsonProcessingException { + List inputs = Optional.ofNullable((List) data.get("variable_selector")) + .filter(list -> list.size() == 2) + .map(list -> Collections.singletonList(new VariableSelector(list.get(0), list.get(1)))) + .orElse(Collections.emptyList()); + + List outputs = List.of(); + + String method = (String) data.getOrDefault("method", "GET"); + String url = (String) data.get("url"); + + // Parse headers + Map headers = Optional.ofNullable((Map) data.get("headers")) + .orElse(Collections.emptyMap()); + + // Parse body + Map body = Optional.ofNullable((Map) data.get("body")) + .orElse(Collections.emptyMap()); + + // Parse streaming configuration + String streamFormat = (String) data.getOrDefault("stream_format", "SSE"); + String streamMode = (String) data.getOrDefault("stream_mode", "DISTRIBUTE"); + String delimiter = (String) data.getOrDefault("delimiter", "\n"); + String outputKey = (String) data.get("output_key"); + Integer timeout = Optional.ofNullable((Integer) data.get("timeout")).orElse(30000); + + // Parse authentication + String authorization = (String) data.get("authorization"); + String authType = (String) data.get("auth_type"); + + StreamHttpNodeData nodeData = new StreamHttpNodeData(inputs, outputs); + nodeData.setMethod(method) + .setUrl(url) + .setHeaders(headers) + .setBody(body) + .setStreamFormat(streamFormat) + .setStreamMode(streamMode) + .setDelimiter(delimiter) + .setOutputKey(outputKey) + .setTimeout(timeout) + .setAuthorization(authorization) + .setAuthType(authType); + + return nodeData; + } + + @Override + public Map dump(StreamHttpNodeData nodeData) { + Map result = new LinkedHashMap<>(); + + // Variable selector + if (!nodeData.getInputs().isEmpty()) { + VariableSelector selector = nodeData.getInputs().get(0); + result.put("variable_selector", List.of(selector.getNamespace(), selector.getName())); + } + + // HTTP configuration + if (!"GET".equals(nodeData.getMethod())) { + result.put("method", nodeData.getMethod()); + } + if (nodeData.getUrl() != null) { + result.put("url", nodeData.getUrl()); + } + if (nodeData.getHeaders() != null && !nodeData.getHeaders().isEmpty()) { + result.put("headers", nodeData.getHeaders()); + } + if (nodeData.getBody() != null && !nodeData.getBody().isEmpty()) { + result.put("body", nodeData.getBody()); + } + + // Streaming configuration + if (!"SSE".equals(nodeData.getStreamFormat())) { + result.put("stream_format", nodeData.getStreamFormat()); + } + if (!"DISTRIBUTE".equals(nodeData.getStreamMode())) { + result.put("stream_mode", nodeData.getStreamMode()); + } + if (!"\n".equals(nodeData.getDelimiter())) { + result.put("delimiter", nodeData.getDelimiter()); + } + if (nodeData.getOutputKey() != null) { + result.put("output_key", nodeData.getOutputKey()); + } + if (nodeData.getTimeout() != null && !nodeData.getTimeout().equals(30000)) { + result.put("timeout", nodeData.getTimeout()); + } + + // Authentication + if (nodeData.getAuthorization() != null) { + result.put("authorization", nodeData.getAuthorization()); + } + if (nodeData.getAuthType() != null) { + result.put("auth_type", nodeData.getAuthType()); + } + + return result; + } + }), + + STUDIO(new DialectConverter<>() { + @Override + public Boolean supportDialect(DSLDialectType dialect) { + return DSLDialectType.STUDIO.equals(dialect); + } + + @SuppressWarnings("unchecked") + @Override + public StreamHttpNodeData parse(Map data) throws JsonProcessingException { + // Studio format parsing - more structured format + List inputs = Collections.emptyList(); + List outputs = List.of(); + + // Parse from config.node_param structure + Map nodeParam = (Map) data.get("node_param"); + if (nodeParam == null) { + nodeParam = data; // fallback to root level + } + + String method = (String) nodeParam.getOrDefault("method", "GET"); + String url = (String) nodeParam.get("url"); + + Map headers = Optional.ofNullable((Map) nodeParam.get("headers")) + .orElse(Collections.emptyMap()); + + Map body = Optional.ofNullable((Map) nodeParam.get("body")) + .orElse(Collections.emptyMap()); + + String streamFormat = (String) nodeParam.getOrDefault("streamFormat", "SSE"); + String streamMode = (String) nodeParam.getOrDefault("streamMode", "DISTRIBUTE"); + String delimiter = (String) nodeParam.getOrDefault("delimiter", "\n"); + String outputKey = (String) nodeParam.get("outputKey"); + Integer timeout = Optional.ofNullable((Integer) nodeParam.get("timeout")).orElse(30000); + + String authorization = (String) nodeParam.get("authorization"); + String authType = (String) nodeParam.get("authType"); + + StreamHttpNodeData nodeData = new StreamHttpNodeData(inputs, outputs); + nodeData.setMethod(method) + .setUrl(url) + .setHeaders(headers) + .setBody(body) + .setStreamFormat(streamFormat) + .setStreamMode(streamMode) + .setDelimiter(delimiter) + .setOutputKey(outputKey) + .setTimeout(timeout) + .setAuthorization(authorization) + .setAuthType(authType); + + return nodeData; + } + + @Override + public Map dump(StreamHttpNodeData nodeData) { + Map result = new LinkedHashMap<>(); + Map nodeParam = new LinkedHashMap<>(); + + // HTTP configuration + nodeParam.put("method", nodeData.getMethod()); + if (nodeData.getUrl() != null) { + nodeParam.put("url", nodeData.getUrl()); + } + if (nodeData.getHeaders() != null) { + nodeParam.put("headers", nodeData.getHeaders()); + } + if (nodeData.getBody() != null) { + nodeParam.put("body", nodeData.getBody()); + } + + // Streaming configuration + nodeParam.put("streamFormat", nodeData.getStreamFormat()); + nodeParam.put("streamMode", nodeData.getStreamMode()); + nodeParam.put("delimiter", nodeData.getDelimiter()); + if (nodeData.getOutputKey() != null) { + nodeParam.put("outputKey", nodeData.getOutputKey()); + } + nodeParam.put("timeout", nodeData.getTimeout()); + + // Authentication + if (nodeData.getAuthorization() != null) { + nodeParam.put("authorization", nodeData.getAuthorization()); + } + if (nodeData.getAuthType() != null) { + nodeParam.put("authType", nodeData.getAuthType()); + } + + result.put("node_param", nodeParam); + return result; + } + }), + + CUSTOM(defaultCustomDialectConverter(StreamHttpNodeData.class)); + + private final DialectConverter converter; + + StreamHttpNodeDialectConverter(DialectConverter converter) { + this.converter = converter; + } + + public DialectConverter dialectConverter() { + return this.converter; + } + + } + + @Override + public String generateVarName(int count) { + return "streamHttpNode" + count; + } + + @Override + public BiConsumer> postProcessConsumer(DSLDialectType dialectType) { + return switch (dialectType) { + case DIFY -> emptyProcessConsumer().andThen((streamHttpNodeData, idToVarName) -> { + // Set output key + streamHttpNodeData.setOutputKey( + streamHttpNodeData.getVarName() + "_" + StreamHttpNodeData.getDefaultOutputSchema().getName()); + streamHttpNodeData.setOutputs(List.of(StreamHttpNodeData.getDefaultOutputSchema())); + }).andThen(super.postProcessConsumer(dialectType)).andThen((streamHttpNodeData, idToVarName) -> { + // Convert Dify variable templates to SAA intermediate variables + if (streamHttpNodeData.getHeaders() != null) { + Map convertedHeaders = streamHttpNodeData.getHeaders() + .entrySet() + .stream() + .collect(Collectors.toMap( + entry -> this.convertVarTemplate(dialectType, entry.getKey().replace("{{#", "${{#"), + idToVarName), + entry -> this.convertVarTemplate(dialectType, entry.getValue().replace("{{#", "${{#"), + idToVarName), + (oldVal, newVal) -> newVal)); + streamHttpNodeData.setHeaders(convertedHeaders); + } + + // Convert URL template variables + if (streamHttpNodeData.getUrl() != null) { + String convertedUrl = this.convertVarTemplate(dialectType, + streamHttpNodeData.getUrl().replace("{{#", "${{#"), idToVarName); + streamHttpNodeData.setUrl(convertedUrl); + } + }); + case STUDIO -> emptyProcessConsumer().andThen((streamHttpNodeData, idToVarName) -> { + // Set output key for Studio format + if (streamHttpNodeData.getOutputKey() == null) { + streamHttpNodeData.setOutputKey(streamHttpNodeData.getVarName() + "_" + + StreamHttpNodeData.getDefaultOutputSchema().getName()); + } + streamHttpNodeData.setOutputs(List.of(StreamHttpNodeData.getDefaultOutputSchema())); + }).andThen(super.postProcessConsumer(dialectType)); + default -> super.postProcessConsumer(dialectType); + }; + } + +} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java new file mode 100644 index 0000000000..505765f281 --- /dev/null +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java @@ -0,0 +1,181 @@ +/* + * Copyright 2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.studio.admin.generator.service.generator.workflow.sections; + +import java.util.List; +import java.util.Map; + +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.Node; +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeType; +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata.StreamHttpNodeData; +import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.DSLDialectType; +import com.alibaba.cloud.ai.studio.admin.generator.service.generator.workflow.NodeSection; + +import org.springframework.stereotype.Component; + +@Component +public class StreamHttpNodeSection implements NodeSection { + + @Override + public boolean support(NodeType nodeType) { + return NodeType.STREAM_HTTP.equals(nodeType); + } + + @Override + public String render(Node node, String varName) { + StreamHttpNodeData d = (StreamHttpNodeData) node.getData(); + String id = node.getId(); + StringBuilder sb = new StringBuilder(); + + sb.append(String.format("// —— StreamHttpNode [%s] ——%n", id)); + sb.append( + String.format("StreamHttpNodeParam.Builder %sParamBuilder = StreamHttpNodeParam.builder()%n", varName)); + sb.append(".webClient(WebClient.create())\n"); + + // HTTP method + if (d.getMethod() != null && !"GET".equals(d.getMethod())) { + sb.append(String.format(".method(HttpMethod.%s)%n", d.getMethod().toUpperCase())); + } + + // URL + if (d.getUrl() != null) { + sb.append(String.format(".url(\"%s\")%n", escape(d.getUrl()))); + } + + // Headers + if (d.getHeaders() != null && !d.getHeaders().isEmpty()) { + sb.append(".headers(Map.of(\n"); + boolean first = true; + for (Map.Entry entry : d.getHeaders().entrySet()) { + if (!first) { + sb.append(",\n"); + } + sb.append(String.format(" \"%s\", \"%s\"", escape(entry.getKey()), escape(entry.getValue()))); + first = false; + } + sb.append("\n))\n"); + } + + // Stream format + if (d.getStreamFormat() != null && !"SSE".equals(d.getStreamFormat())) { + sb.append(String.format(".streamFormat(StreamHttpNodeParam.StreamFormat.%s)%n", d.getStreamFormat())); + } + + // Stream mode + if (d.getStreamMode() != null && !"DISTRIBUTE".equals(d.getStreamMode())) { + sb.append(String.format(".streamMode(StreamHttpNodeParam.StreamMode.%s)%n", d.getStreamMode())); + } + + // Delimiter + if (d.getDelimiter() != null && !"\n".equals(d.getDelimiter())) { + sb.append(String.format(".delimiter(\"%s\")%n", escape(d.getDelimiter()))); + } + + // Output key + if (d.getOutputKey() != null) { + sb.append(String.format(".outputKey(\"%s\")%n", escape(d.getOutputKey()))); + } + + // Timeout + if (d.getTimeout() != null && !d.getTimeout().equals(30000)) { + sb.append(String.format(".readTimeout(Duration.ofMillis(%d))%n", d.getTimeout())); + } + + sb.append(";\n"); + + // Create StreamHttpNode + sb.append(String.format("StreamHttpNode %s = new StreamHttpNode(%sParamBuilder.build());%n", varName, varName)); + + // Add to state graph as async node since it's streaming + String assistNodeCode = String.format("wrapperStreamHttpNodeAction(%s, \"%s\")", varName, varName); + sb.append(String.format("stateGraph.addNode(\"%s\", AsyncNodeAction.node_async(%s));%n%n", varName, + assistNodeCode)); + + return sb.toString(); + } + + @Override + public String assistMethodCode(DSLDialectType dialectType) { + return switch (dialectType) { + case DIFY -> """ + private NodeAction wrapperStreamHttpNodeAction(StreamHttpNode streamHttpNode, String varName) { + return state -> { + try { + Flux> resultFlux = streamHttpNode.executeStreaming(state); + List> results = resultFlux.collectList().block(); + + Map output = new HashMap<>(); + if (results != null && !results.isEmpty()) { + output.put(varName + "_data", results); + output.put(varName + "_status", "success"); + output.put(varName + "_count", results.size()); + } else { + output.put(varName + "_data", Collections.emptyList()); + output.put(varName + "_status", "empty"); + output.put(varName + "_count", 0); + } + return output; + } catch (Exception e) { + return Map.of( + varName + "_data", Collections.emptyList(), + varName + "_status", "error", + varName + "_error", e.getMessage() + ); + } + }; + } + """; + case STUDIO -> """ + private NodeAction wrapperStreamHttpNodeAction(StreamHttpNode streamHttpNode, String varName) { + return state -> { + try { + Flux> resultFlux = streamHttpNode.executeStreaming(state); + List> results = resultFlux.collectList().block(); + + Map output = new HashMap<>(); + if (results != null && !results.isEmpty()) { + output.put("data", results); + output.put("status", "success"); + } else { + output.put("data", Collections.emptyList()); + output.put("status", "empty"); + } + return output; + } catch (Exception e) { + return Map.of( + "data", Collections.emptyList(), + "status", "error", + "error", e.getMessage() + ); + } + }; + } + """; + default -> ""; + }; + } + + @Override + public List getImports() { + return List.of("com.alibaba.cloud.ai.graph.node.StreamHttpNode", + "com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam", + "org.springframework.web.reactive.function.client.WebClient", "org.springframework.http.HttpMethod", + "reactor.core.publisher.Flux", "java.time.Duration", "java.util.Map", "java.util.HashMap", + "java.util.List", "java.util.Collections"); + } + +} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java new file mode 100644 index 0000000000..70bacc1304 --- /dev/null +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java @@ -0,0 +1,197 @@ +/* + * Copyright 2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.studio.admin.generator.service.dsl.converter; + +import java.util.List; +import java.util.Map; + +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeType; +import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata.StreamHttpNodeData; +import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.DSLDialectType; + +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.extension.ExtendWith; +import org.mockito.InjectMocks; +import org.mockito.junit.jupiter.MockitoExtension; + +import static org.assertj.core.api.Assertions.assertThat; + +@ExtendWith(MockitoExtension.class) +class StreamHttpNodeDataConverterTest { + + @InjectMocks + private StreamHttpNodeDataConverter converter; + + @Test + void shouldSupportStreamHttpNodeType() { + assertThat(converter.supportNodeType(NodeType.STREAM_HTTP)).isTrue(); + assertThat(converter.supportNodeType(NodeType.HTTP)).isFalse(); + assertThat(converter.supportNodeType(NodeType.LLM)).isFalse(); + } + + @Test + void shouldGenerateCorrectVarName() { + assertThat(converter.generateVarName(1)).isEqualTo("streamHttpNode1"); + assertThat(converter.generateVarName(5)).isEqualTo("streamHttpNode5"); + } + + @Test + void shouldParseDifyDSLFormat() throws Exception { + // Given + Map dslData = new java.util.HashMap<>(); + dslData.put("method", "POST"); + dslData.put("url", "https://api.example.com/stream"); + dslData.put("headers", Map.of("Authorization", "Bearer token123", "Content-Type", "application/json")); + dslData.put("body", Map.of("query", "test query")); + dslData.put("stream_format", "SSE"); + dslData.put("stream_mode", "DISTRIBUTE"); + dslData.put("delimiter", "\n"); + dslData.put("output_key", "stream_results"); + dslData.put("timeout", 60000); + dslData.put("authorization", "Bearer token123"); + dslData.put("auth_type", "BEARER"); + + // When + StreamHttpNodeData result = converter.parseMapData(dslData, DSLDialectType.DIFY); + + // Then + assertThat(result).isNotNull(); + assertThat(result.getMethod()).isEqualTo("POST"); + assertThat(result.getUrl()).isEqualTo("https://api.example.com/stream"); + assertThat(result.getHeaders()).containsEntry("Authorization", "Bearer token123"); + assertThat(result.getHeaders()).containsEntry("Content-Type", "application/json"); + assertThat(result.getBody()).containsEntry("query", "test query"); + assertThat(result.getStreamFormat()).isEqualTo("SSE"); + assertThat(result.getStreamMode()).isEqualTo("DISTRIBUTE"); + assertThat(result.getDelimiter()).isEqualTo("\n"); + assertThat(result.getOutputKey()).isEqualTo("stream_results"); + assertThat(result.getTimeout()).isEqualTo(60000); + assertThat(result.getAuthorization()).isEqualTo("Bearer token123"); + assertThat(result.getAuthType()).isEqualTo("BEARER"); + } + + @Test + void shouldDumpToDifyDSLFormat() throws Exception { + // Given + StreamHttpNodeData nodeData = new StreamHttpNodeData(List.of(), List.of()); + nodeData.setMethod("POST") + .setUrl("https://api.example.com/stream") + .setHeaders(Map.of("Authorization", "Bearer token123")) + .setBody(Map.of("query", "test query")) + .setStreamFormat("JSON_LINES") + .setStreamMode("AGGREGATE") + .setDelimiter("|") + .setOutputKey("results") + .setTimeout(45000) + .setAuthorization("Bearer token123") + .setAuthType("BEARER"); + + // When + Map result = converter.dumpMapData(nodeData, DSLDialectType.DIFY); + + // Then + assertThat(result).isNotNull(); + assertThat(result.get("method")).isEqualTo("POST"); + assertThat(result.get("url")).isEqualTo("https://api.example.com/stream"); + assertThat(result.get("headers")).isEqualTo(Map.of("Authorization", "Bearer token123")); + assertThat(result.get("body")).isEqualTo(Map.of("query", "test query")); + assertThat(result.get("stream_format")).isEqualTo("JSON_LINES"); + assertThat(result.get("stream_mode")).isEqualTo("AGGREGATE"); + assertThat(result.get("delimiter")).isEqualTo("|"); + assertThat(result.get("output_key")).isEqualTo("results"); + assertThat(result.get("timeout")).isEqualTo(45000); + assertThat(result.get("authorization")).isEqualTo("Bearer token123"); + assertThat(result.get("auth_type")).isEqualTo("BEARER"); + } + + @Test + void shouldParseStudioDSLFormat() throws Exception { + // Given + Map nodeParam = new java.util.HashMap<>(); + nodeParam.put("method", "GET"); + nodeParam.put("url", "https://api.example.com/events"); + nodeParam.put("headers", Map.of("Accept", "text/event-stream")); + nodeParam.put("streamFormat", "SSE"); + nodeParam.put("streamMode", "DISTRIBUTE"); + nodeParam.put("delimiter", "\n"); + nodeParam.put("outputKey", "events"); + nodeParam.put("timeout", 30000); + + Map dslData = Map.of("node_param", nodeParam); + + // When + StreamHttpNodeData result = converter.parseMapData(dslData, DSLDialectType.STUDIO); + + // Then + assertThat(result).isNotNull(); + assertThat(result.getMethod()).isEqualTo("GET"); + assertThat(result.getUrl()).isEqualTo("https://api.example.com/events"); + assertThat(result.getHeaders()).containsEntry("Accept", "text/event-stream"); + assertThat(result.getStreamFormat()).isEqualTo("SSE"); + assertThat(result.getStreamMode()).isEqualTo("DISTRIBUTE"); + assertThat(result.getOutputKey()).isEqualTo("events"); + assertThat(result.getTimeout()).isEqualTo(30000); + } + + @Test + void shouldDumpToStudioDSLFormat() throws Exception { + // Given + StreamHttpNodeData nodeData = new StreamHttpNodeData(List.of(), List.of()); + nodeData.setMethod("GET") + .setUrl("https://api.example.com/events") + .setHeaders(Map.of("Accept", "text/event-stream")) + .setStreamFormat("SSE") + .setStreamMode("DISTRIBUTE") + .setOutputKey("events") + .setTimeout(30000); + + // When + Map result = converter.dumpMapData(nodeData, DSLDialectType.STUDIO); + + // Then + assertThat(result).isNotNull(); + @SuppressWarnings("unchecked") + Map nodeParam = (Map) result.get("node_param"); + assertThat(nodeParam).isNotNull(); + assertThat(nodeParam.get("method")).isEqualTo("GET"); + assertThat(nodeParam.get("url")).isEqualTo("https://api.example.com/events"); + assertThat(nodeParam.get("headers")).isEqualTo(Map.of("Accept", "text/event-stream")); + assertThat(nodeParam.get("streamFormat")).isEqualTo("SSE"); + assertThat(nodeParam.get("streamMode")).isEqualTo("DISTRIBUTE"); + assertThat(nodeParam.get("outputKey")).isEqualTo("events"); + assertThat(nodeParam.get("timeout")).isEqualTo(30000); + } + + @Test + void shouldHandleDefaultValues() throws Exception { + // Given - minimal DSL data + Map dslData = Map.of("url", "https://api.example.com/stream"); + + // When + StreamHttpNodeData result = converter.parseMapData(dslData, DSLDialectType.DIFY); + + // Then + assertThat(result).isNotNull(); + assertThat(result.getMethod()).isEqualTo("GET"); // default + assertThat(result.getUrl()).isEqualTo("https://api.example.com/stream"); + assertThat(result.getStreamFormat()).isEqualTo("SSE"); // default + assertThat(result.getStreamMode()).isEqualTo("DISTRIBUTE"); // default + assertThat(result.getDelimiter()).isEqualTo("\n"); // default + assertThat(result.getTimeout()).isEqualTo(30000); // default + } + +} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml index 4723ea7d14..1335c5cca2 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml @@ -94,6 +94,12 @@ spring-ai-alibaba-core + + com.alibaba.cloud.ai + spring-ai-alibaba-graph-core + ${project.version} + + io.netty netty-resolver-dns-native-macos diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java new file mode 100644 index 0000000000..de8c313400 --- /dev/null +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java @@ -0,0 +1,214 @@ +/* + * Copyright 2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.studio.core.workflow.processor.impl; + +import com.alibaba.cloud.ai.studio.runtime.domain.workflow.Edge; +import com.alibaba.cloud.ai.studio.runtime.domain.workflow.Node; +import com.alibaba.cloud.ai.studio.runtime.domain.workflow.NodeResult; +import com.alibaba.cloud.ai.studio.runtime.domain.workflow.NodeTypeEnum; +import com.alibaba.cloud.ai.studio.runtime.utils.JsonUtils; +import com.alibaba.cloud.ai.studio.core.config.CommonConfig; +import com.alibaba.cloud.ai.studio.core.base.manager.RedisManager; +import com.alibaba.cloud.ai.studio.core.workflow.WorkflowContext; +import com.alibaba.cloud.ai.studio.core.workflow.WorkflowInnerService; +import com.alibaba.cloud.ai.studio.core.workflow.processor.AbstractExecuteProcessor; +import com.alibaba.cloud.ai.graph.OverAllState; +import com.alibaba.cloud.ai.graph.node.StreamHttpNode; +import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam; +import com.fasterxml.jackson.annotation.JsonProperty; +import lombok.Data; +import lombok.extern.slf4j.Slf4j; +import org.jgrapht.graph.DirectedAcyclicGraph; +import org.springframework.ai.chat.memory.ChatMemory; +import org.springframework.http.HttpMethod; +import org.springframework.stereotype.Component; +import org.springframework.web.reactive.function.client.WebClient; +import reactor.core.publisher.Flux; + +import java.time.Duration; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Slf4j +@Component("StreamHttpExecuteProcessor") +public class StreamHttpExecuteProcessor extends AbstractExecuteProcessor { + + public StreamHttpExecuteProcessor(RedisManager redisManager, WorkflowInnerService workflowInnerService, + ChatMemory conversationChatMemory, CommonConfig commonConfig) { + super(redisManager, workflowInnerService, conversationChatMemory, commonConfig); + } + + /** + * Executes the StreamHttp node in the workflow + * @param graph The workflow graph + * @param node The StreamHttp node to execute + * @param context The workflow context + * @return NodeResult containing streaming call status and response + */ + @Override + public NodeResult innerExecute(DirectedAcyclicGraph graph, Node node, WorkflowContext context) { + + // Initialize and refresh context + NodeResult nodeResult = initNodeResultAndRefreshContext(node, context); + + try { + NodeParam config = JsonUtils.fromMap(node.getConfig().getNodeParam(), NodeParam.class); + + // Build StreamHttpNodeParam from config + StreamHttpNodeParam.Builder paramBuilder = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.valueOf(config.getMethod().toUpperCase())) + .url(replaceTemplateContent(config.getUrl(), context)) + .streamFormat(StreamHttpNodeParam.StreamFormat.valueOf(config.getStreamFormat())) + .streamMode(StreamHttpNodeParam.StreamMode.valueOf(config.getStreamMode())) + .delimiter(config.getDelimiter()) + .outputKey(config.getOutputKey()) + .readTimeout(Duration.ofMillis(config.getTimeout())); + + // Add headers if present + if (config.getHeaders() != null && !config.getHeaders().isEmpty()) { + Map headers = new HashMap<>(); + config.getHeaders().forEach(header -> { + String value = replaceTemplateContent(header.getValue(), context); + headers.put(header.getKey(), value); + }); + paramBuilder.headers(headers); + } + + // Add body if present (skip body configuration for now) + // TODO: Implement proper body configuration conversion + + StreamHttpNodeParam streamParam = paramBuilder.build(); + StreamHttpNode streamHttpNode = new StreamHttpNode(streamParam); + + // Create OverAllState from workflow context + OverAllState state = createOverAllState(context); + + // Execute streaming and collect results + Flux> resultFlux = streamHttpNode.executeStreaming(state); + + // For workflow integration, we need to collect the streaming results + // This is a blocking operation for workflow compatibility + List> results = resultFlux.collectList().block(); + + // Set results + Map output = new HashMap<>(); + if (results != null && !results.isEmpty()) { + if (config.getOutputKey() != null && !config.getOutputKey().isEmpty()) { + output.put(config.getOutputKey(), results); + } + else { + // If no output key specified, put results directly + if (results.size() == 1) { + output.putAll(results.get(0)); + } + else { + output.put("results", results); + } + } + } + + nodeResult.setOutput(JsonUtils.toJson(output)); + nodeResult.setNodeId(node.getId()); + nodeResult.setNodeType(node.getType()); + + log.info("StreamHttp node executed successfully, nodeId: {}, resultsCount: {}", node.getId(), + results != null ? results.size() : 0); + + } + catch (Exception e) { + log.error("StreamHttp node execution failed, nodeId: {}", node.getId(), e); + nodeResult.setNodeStatus(com.alibaba.cloud.ai.studio.runtime.domain.workflow.NodeStatusEnum.FAIL.getCode()); + nodeResult.setOutput(null); + nodeResult.setErrorInfo("StreamHttp node exception: " + e.getMessage()); + nodeResult.setError(com.alibaba.cloud.ai.studio.runtime.enums.ErrorCode.WORKFLOW_EXECUTE_ERROR + .toError("StreamHttp node exception: " + e.getMessage())); + } + + return nodeResult; + } + + @Override + public String getNodeType() { + return NodeTypeEnum.STREAM_HTTP.getCode(); + } + + @Override + public String getNodeDescription() { + return NodeTypeEnum.STREAM_HTTP.getDesc(); + } + + /** + * Create OverAllState from WorkflowContext + */ + private OverAllState createOverAllState(WorkflowContext context) { + Map stateData = new HashMap<>(); + // Copy variables from workflow context to state + if (context.getVariablesMap() != null) { + stateData.putAll(context.getVariablesMap()); + } + return new OverAllState(stateData); + } + + /** + * Node parameter configuration + */ + @Data + public static class NodeParam { + + @JsonProperty("method") + private String method = "GET"; + + @JsonProperty("url") + private String url; + + @JsonProperty("headers") + private List headers; + + @JsonProperty("body") + private Map body; + + @JsonProperty("streamFormat") + private String streamFormat = "SSE"; + + @JsonProperty("streamMode") + private String streamMode = "DISTRIBUTE"; + + @JsonProperty("delimiter") + private String delimiter = "\n"; + + @JsonProperty("outputKey") + private String outputKey; + + @JsonProperty("timeout") + private int timeout = 30000; // 30 seconds default + + @Data + public static class HeaderParam { + + @JsonProperty("key") + private String key; + + @JsonProperty("value") + private String value; + + } + + } + +} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java index f10b5a63a9..1e6b403be7 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java @@ -24,11 +24,11 @@ public enum NodeTypeEnum { VARIABLE_ASSIGN("VariableAssign", "变量赋值节点"), VARIABLE_HANDLE("VariableHandle", "变量处理节点"), APP_CUSTOM("AppCustom", "自定义应用节点"), AGENT_GROUP("AgentGroup", "智能体组节点"), SCRIPT("Script", "脚本节点"), CLASSIFIER("Classifier", "问题分类节点"), LLM("LLM", "大模型节点"), COMPONENT("AppComponent", "应用组件节点"), - JUDGE("Judge", "判断节点"), RETRIEVAL("Retrieval", "知识库节点"), API("API", "Api调用节点"), PLUGIN("Plugin", "插件节点"), - MCP("MCP", "MCP节点"), PARAMETER_EXTRACTOR("ParameterExtractor", "参数提取节点"), - ITERATOR_START("IteratorStart", "循环体开始节点"), ITERATOR("Iterator", "循环节点"), ITERATOR_END("IteratorEnd", "循环体结束节点"), - PARALLEL_START("ParallelStart", "批处理开始节点"), PARALLEL("Parallel", "批处理节点"), PARALLEL_END("ParallelEnd", "批处理结束节点"), - END("End", "结束节点"); + JUDGE("Judge", "判断节点"), RETRIEVAL("Retrieval", "知识库节点"), API("API", "Api调用节点"), + STREAM_HTTP("StreamHttp", "流式HTTP节点"), PLUGIN("Plugin", "插件节点"), MCP("MCP", "MCP节点"), + PARAMETER_EXTRACTOR("ParameterExtractor", "参数提取节点"), ITERATOR_START("IteratorStart", "循环体开始节点"), + ITERATOR("Iterator", "循环节点"), ITERATOR_END("IteratorEnd", "循环体结束节点"), PARALLEL_START("ParallelStart", "批处理开始节点"), + PARALLEL("Parallel", "批处理节点"), PARALLEL_END("ParallelEnd", "批处理结束节点"), END("End", "结束节点"); private final String code; From cdaf12c75ad5a25476c2ac08d7a6bf606c992280 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Thu, 18 Sep 2025 13:07:15 +0800 Subject: [PATCH 02/11] Update StreamHttpNode.java --- .../java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java index 6cf8d19aa0..6fe833edd3 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java @@ -366,7 +366,7 @@ private void initBody(WebClient.RequestBodySpec requestSpec, OverAllState state) } String jsonTemplate = replaceVariables(param.getBody().getData().get(0).getValue(), state); try { - Object jsonObject = HttpNode.parseNestedJson(jsonTemplate); + Object jsonObject = objectMapper.readValue(jsonTemplate, Object.class); requestSpec.headers(h -> h.setContentType(MediaType.APPLICATION_JSON)); requestSpec.bodyValue(jsonObject); } From c445dc4021586aa72afd76b655911d5c0748b422 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Thu, 18 Sep 2025 14:29:40 +0800 Subject: [PATCH 03/11] fix(graph):remove studio streamhttpnode --- .../alibaba/cloud/ai/graph/node/HttpNode.java | 2 +- .../graph/streaming/StreamHttpException.java | 85 +++++ .../{node => streaming}/StreamHttpNode.java | 61 +++- .../StreamHttpNodeParam.java | 63 +++- .../StreamHttpNodeTest.java | 191 ++++++++++- .../generator/model/workflow/NodeType.java | 4 +- .../workflow/nodedata/StreamHttpNodeData.java | 166 --------- .../StreamHttpNodeDataConverter.java | 314 ------------------ .../sections/StreamHttpNodeSection.java | 181 ---------- .../StreamHttpNodeDataConverterTest.java | 197 ----------- .../impl/StreamHttpExecuteProcessor.java | 214 ------------ .../runtime/domain/workflow/NodeTypeEnum.java | 2 +- 12 files changed, 392 insertions(+), 1088 deletions(-) create mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java rename spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/{node => streaming}/StreamHttpNode.java (83%) rename spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/{node => streaming}/StreamHttpNodeParam.java (77%) rename spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/{node => streaming}/StreamHttpNodeTest.java (73%) delete mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java delete mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java delete mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java delete mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java delete mode 100644 spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java index aab21c0d63..6854c31ed6 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java @@ -724,7 +724,7 @@ public boolean hasContent() { public static class AuthConfig { - enum AuthType { + public enum AuthType { BASIC, BEARER diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java new file mode 100644 index 0000000000..399d9afe2a --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java @@ -0,0 +1,85 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.cloud.ai.graph.streaming; + +/** + * StreamHttpNode专用异常类 提供更详细的流式HTTP处理异常信息 + */ +public class StreamHttpException extends RuntimeException { + + private final String nodeId; + + private final int httpStatus; + + private final String url; + + public StreamHttpException(String nodeId, String url, String message) { + this(nodeId, url, -1, message, null); + } + + public StreamHttpException(String nodeId, String url, String message, Throwable cause) { + this(nodeId, url, -1, message, cause); + } + + public StreamHttpException(String nodeId, String url, int httpStatus, String message, Throwable cause) { + super(String.format("StreamHttpNode[%s] failed: %s (URL: %s, Status: %d)", nodeId, message, url, httpStatus), + cause); + this.nodeId = nodeId; + this.httpStatus = httpStatus; + this.url = url; + } + + public String getNodeId() { + return nodeId; + } + + public int getHttpStatus() { + return httpStatus; + } + + public String getUrl() { + return url; + } + + /** + * 创建网络异常 + */ + public static StreamHttpException networkError(String nodeId, String url, Throwable cause) { + return new StreamHttpException(nodeId, url, "Network connection failed", cause); + } + + /** + * 创建HTTP状态异常 + */ + public static StreamHttpException httpError(String nodeId, String url, int status, String message) { + return new StreamHttpException(nodeId, url, status, "HTTP error: " + message, null); + } + + /** + * 创建数据解析异常 + */ + public static StreamHttpException parseError(String nodeId, String url, String message, Throwable cause) { + return new StreamHttpException(nodeId, url, "Data parsing failed: " + message, cause); + } + + /** + * 创建超时异常 + */ + public static StreamHttpException timeoutError(String nodeId, String url, String message) { + return new StreamHttpException(nodeId, url, "Request timeout: " + message, null); + } + +} diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java similarity index 83% rename from spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java rename to spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java index 6fe833edd3..0f3315265a 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java @@ -13,13 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.alibaba.cloud.ai.graph.node; +package com.alibaba.cloud.ai.graph.streaming; import com.alibaba.cloud.ai.graph.OverAllState; import com.alibaba.cloud.ai.graph.action.StreamingGraphNode; import com.alibaba.cloud.ai.graph.exception.GraphRunnerException; import com.alibaba.cloud.ai.graph.exception.RunnableErrors; -import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamMode; +import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamMode; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.JsonNode; import com.fasterxml.jackson.databind.ObjectMapper; @@ -44,7 +44,7 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; -import static com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamFormat.*; +import static com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamFormat.*; public class StreamHttpNode implements StreamingGraphNode { @@ -66,6 +66,7 @@ public StreamHttpNode(StreamHttpNodeParam param) { public Flux> executeStreaming(OverAllState state) throws Exception { try { String finalUrl = replaceVariables(param.getUrl(), state); + validateUrl(finalUrl); // 添加URL安全验证 Map finalHeaders = replaceVariables(param.getHeaders(), state); Map finalQueryParams = replaceVariables(param.getQueryParams(), state); @@ -106,13 +107,15 @@ public Flux> executeStreaming(OverAllState state) throws Exc .timeout(param.getReadTimeout()) // 处理网络超时、连接错误等其他异常 .onErrorResume(throwable -> { - logger.error("Stream processing failed", throwable); + logger.error("StreamHttpNode execution failed: url={}, method={}, error={}", finalUrl, + param.getMethod(), throwable.getMessage(), throwable); return Flux.just(createErrorOutput(throwable)); }); } catch (Exception e) { - logger.error("StreamHttpNode execution failed", e); + logger.error("StreamHttpNode initialization failed: url={}, method={}, error={}", param.getUrl(), + param.getMethod(), e.getMessage(), e); // 返回错误输出而不是抛出异常 return Flux.just(createErrorOutput(e)); } @@ -127,7 +130,8 @@ private Flux> processStreamResponse(Flux respons dataBuffer.read(bytes); return new String(bytes, StandardCharsets.UTF_8); }) - .scan("", (accumulated, chunk) -> accumulated + chunk) + .buffer(param.getBufferTimeout()) // 使用配置的缓冲超时时间避免内存累积 + .map(chunks -> String.join("", chunks)) .flatMap(this::parseStreamChunk) .filter(data -> !data.isEmpty()) .map(this::wrapOutput) @@ -187,7 +191,11 @@ private Flux parseJsonLinesChunk(String chunk) { results.add(line); } catch (JsonProcessingException e) { - logger.debug("Skipping invalid JSON line: {}", line); + logger.warn("Invalid JSON line: {}, error: {}", line, e.getMessage()); + // 返回包含错误信息的特殊标记，保留原始数据用于调试 + String errorJson = String.format("{\"_parsing_error\": \"%s\", \"_raw_data\": \"%s\"}", + e.getMessage().replaceAll("\"", "\\\\\""), line.replaceAll("\"", "\\\\\"")); + results.add(errorJson); } } } @@ -379,6 +387,45 @@ private void initBody(WebClient.RequestBodySpec requestSpec, OverAllState state) } } + /** + * URL安全验证 + */ + private void validateUrl(String url) { + try { + URI uri = URI.create(url); + String host = uri.getHost(); + + if (host == null) { + throw new IllegalArgumentException("Invalid URL: missing host"); + } + + // 检查内网地址访问权限 + if (isInternalAddress(host) && !param.isAllowInternalAddress()) { + throw new SecurityException( + "Internal network access not allowed: " + host + ". Set allowInternalAddress=true to enable."); + } + + // 验证协议 + String scheme = uri.getScheme(); + if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) { + throw new IllegalArgumentException("Only HTTP/HTTPS protocols are supported: " + scheme); + } + + } + catch (IllegalArgumentException | SecurityException e) { + throw new StreamHttpException("stream-http", url, "URL validation failed: " + e.getMessage(), e); + } + } + + /** + * 检查是否为内网地址 + */ + private boolean isInternalAddress(String host) { + // 简单的内网地址检查 + return host.startsWith("127.") || host.startsWith("10.") || host.startsWith("192.168.") + || host.matches("172\\.(1[6-9]|2[0-9]|3[0-1])\\..*") || "localhost".equalsIgnoreCase(host); + } + /** * 构建器模式的工厂方法 */ diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java similarity index 77% rename from spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java rename to spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java index f60d1aa7c2..55d8d20c11 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeParam.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java @@ -13,7 +13,7 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.alibaba.cloud.ai.graph.node; +package com.alibaba.cloud.ai.graph.streaming; import com.alibaba.cloud.ai.graph.node.HttpNode.AuthConfig; import com.alibaba.cloud.ai.graph.node.HttpNode.HttpRequestNodeBody; @@ -48,6 +48,15 @@ public class StreamHttpNodeParam { // 流式处理特有的配置 private StreamFormat streamFormat = StreamFormat.SSE; + // 性能和安全配置 + private long maxResponseSize = 50 * 1024 * 1024; // 50MB限制 + + private int maxRedirects = 5; // 重定向次数限制 + + private boolean allowInternalAddress = false; // 是否允许访问内网地址 + + private Duration bufferTimeout = Duration.ofMillis(100); // 缓冲超时时间 + private StreamMode streamMode = StreamMode.DISTRIBUTE; private Duration readTimeout = Duration.ofMinutes(5); @@ -181,6 +190,26 @@ public Builder delimiter(String delimiter) { return this; } + public Builder allowInternalAddress(boolean allowInternalAddress) { + param.allowInternalAddress = allowInternalAddress; + return this; + } + + public Builder bufferTimeout(Duration bufferTimeout) { + param.bufferTimeout = bufferTimeout; + return this; + } + + public Builder maxResponseSize(long maxResponseSize) { + param.maxResponseSize = maxResponseSize; + return this; + } + + public Builder maxRedirects(int maxRedirects) { + param.maxRedirects = maxRedirects; + return this; + } + public StreamHttpNodeParam build() { if (param.url == null || param.url.trim().isEmpty()) { throw new IllegalArgumentException("URL cannot be null or empty"); @@ -247,4 +276,36 @@ public String getDelimiter() { return delimiter; } + public long getMaxResponseSize() { + return maxResponseSize; + } + + public void setMaxResponseSize(long maxResponseSize) { + this.maxResponseSize = maxResponseSize; + } + + public int getMaxRedirects() { + return maxRedirects; + } + + public void setMaxRedirects(int maxRedirects) { + this.maxRedirects = maxRedirects; + } + + public boolean isAllowInternalAddress() { + return allowInternalAddress; + } + + public void setAllowInternalAddress(boolean allowInternalAddress) { + this.allowInternalAddress = allowInternalAddress; + } + + public Duration getBufferTimeout() { + return bufferTimeout; + } + + public void setBufferTimeout(Duration bufferTimeout) { + this.bufferTimeout = bufferTimeout; + } + } diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java similarity index 73% rename from spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java rename to spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java index 2e1d9d6328..3e0a4e113b 100644 --- a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamHttpNodeTest.java +++ b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java @@ -13,12 +13,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package com.alibaba.cloud.ai.graph.node; +package com.alibaba.cloud.ai.graph.streaming; import com.alibaba.cloud.ai.graph.OverAllState; import com.alibaba.cloud.ai.graph.OverAllStateBuilder; -import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamFormat; -import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam.StreamMode; +import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamFormat; +import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamMode; import okhttp3.mockwebserver.MockResponse; import okhttp3.mockwebserver.MockWebServer; import org.junit.jupiter.api.AfterEach; @@ -528,4 +528,189 @@ void testSimpleHttpRequest() throws Exception { }).verifyComplete(); } + // ==================== 新增的改进功能测试 ==================== + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testUrlValidation_ShouldRejectInternalAddress() throws Exception { + // 测试URL安全验证 - 拒绝内网地址 + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url("http://192.168.1.1/test") // 内网地址 + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .allowInternalAddress(false) // 禁止内网访问 + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { + // 验证返回错误信息 + assertThat(output).containsKey("error"); + assertThat(output.get("error").toString()).contains("Internal network access not allowed"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testUrlValidation_ShouldAllowInternalAddressWhenConfigured() throws Exception { + // 测试URL安全验证 - 配置允许时可以访问内网地址 + mockWebServer.enqueue(new MockResponse().setBody("{\"internal\": \"success\"}") + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/internal").toString()) // 本地mock服务器 + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .allowInternalAddress(true) // 允许内网访问 + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { + // 验证正常处理 + assertThat(output).containsKey("data"); + assertThat(output.get("streaming")).isEqualTo(true); + }).verifyComplete(); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testJsonLinesWithErrorHandling() throws Exception { + // 测试改进的JSON解析错误处理 + String jsonLinesWithError = """ + {"valid": "json"} + {invalid json line + {"another": "valid"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonLinesWithError) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/jsonlines-error").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { + // 第一个有效JSON + assertThat(output).containsKey("data"); + Map data = (Map) output.get("data"); + assertThat(data).containsKey("valid"); + }).assertNext(output -> { + // 解析错误的JSON，应该包含错误信息 + assertThat(output).containsKey("data"); + Map data = (Map) output.get("data"); + assertThat(data).containsKey("_parsing_error"); + assertThat(data).containsKey("_raw_data"); + }).assertNext(output -> { + // 第三个有效JSON + assertThat(output).containsKey("data"); + Map data = (Map) output.get("data"); + assertThat(data).containsKey("another"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testCustomBufferTimeout() throws Exception { + // 测试自定义缓冲超时配置 + String streamResponse = """ + {"chunk": 1} + {"chunk": 2} + {"chunk": 3} + """; + + mockWebServer.enqueue(new MockResponse().setBody(streamResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/buffer-test").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .bufferTimeout(Duration.ofMillis(50)) // 自定义缓冲超时 + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { + assertThat(output).containsKey("data"); + assertThat(output.get("streaming")).isEqualTo(true); + }).assertNext(output -> { + assertThat(output).containsKey("data"); + }).assertNext(output -> { + assertThat(output).containsKey("data"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testInvalidProtocolValidation() throws Exception { + // 测试协议验证 - 拒绝非HTTP/HTTPS协议 + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url("ftp://example.com/test") // 不支持的协议 + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { + // 验证返回错误信息 + assertThat(output).containsKey("error"); + assertThat(output.get("error").toString()).contains("Only HTTP/HTTPS protocols are supported"); + }).verifyComplete(); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testStructuredErrorLogging() throws Exception { + // 测试结构化错误日志记录 + mockWebServer.enqueue(new MockResponse().setResponseCode(500).setBody("Internal Server Error")); + + StreamHttpNodeParam param = StreamHttpNodeParam.builder() + .webClient(WebClient.create()) + .method(HttpMethod.GET) + .url(mockWebServer.url("/error").toString()) + .streamFormat(StreamFormat.JSON_LINES) + .streamMode(StreamMode.DISTRIBUTE) + .build(); + + streamHttpNode = new StreamHttpNode(param); + + Flux> result = streamHttpNode.executeStreaming(testState); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { + // 验证错误输出格式 + assertThat(output).containsKey("error"); + assertThat(output.get("streaming")).isEqualTo(false); + assertThat(output).containsKey("timestamp"); + }).verifyComplete(); + } + } diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java index f5cbfd4c22..91d601d667 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java @@ -67,9 +67,7 @@ public enum NodeType { ITERATION_END("iteration-end", "iteration-end", "ParallelEnd"), - ASSIGNER("assigner", "assigner", "UNSUPPORTED"), - - STREAM_HTTP("stream-http", "stream-http", "StreamHttp"); + ASSIGNER("assigner", "assigner", "UNSUPPORTED"); private final String value; diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java deleted file mode 100644 index 577599b534..0000000000 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/nodedata/StreamHttpNodeData.java +++ /dev/null @@ -1,166 +0,0 @@ -/* - * Copyright 2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata; - -import java.util.Collections; -import java.util.List; -import java.util.Map; - -import com.alibaba.cloud.ai.studio.admin.generator.model.Variable; -import com.alibaba.cloud.ai.studio.admin.generator.model.VariableSelector; -import com.alibaba.cloud.ai.studio.admin.generator.model.VariableType; -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeData; - -public class StreamHttpNodeData extends NodeData { - - public static Variable getDefaultOutputSchema() { - return new Variable("response", VariableType.ARRAY_STRING); - } - - // HTTP request configuration - private String method = "GET"; - - private String url; - - private Map headers; - - private Map body; - - // Streaming configuration - private String streamFormat = "SSE"; // SSE, JSON_LINES, TEXT_STREAM - - private String streamMode = "DISTRIBUTE"; // DISTRIBUTE, AGGREGATE - - private String delimiter = "\n"; - - private String outputKey; - - private Integer timeout = 30000; // 30 seconds default - - // Authentication configuration (if needed) - private String authorization; - - private String authType; // BEARER, BASIC, API_KEY - - public StreamHttpNodeData() { - super(Collections.emptyList(), Collections.emptyList()); - } - - public StreamHttpNodeData(List inputs, List outputs) { - super(inputs, outputs); - } - - public String getMethod() { - return method; - } - - public StreamHttpNodeData setMethod(String method) { - this.method = method; - return this; - } - - public String getUrl() { - return url; - } - - public StreamHttpNodeData setUrl(String url) { - this.url = url; - return this; - } - - public Map getHeaders() { - return headers; - } - - public StreamHttpNodeData setHeaders(Map headers) { - this.headers = headers; - return this; - } - - public Map getBody() { - return body; - } - - public StreamHttpNodeData setBody(Map body) { - this.body = body; - return this; - } - - public String getStreamFormat() { - return streamFormat; - } - - public StreamHttpNodeData setStreamFormat(String streamFormat) { - this.streamFormat = streamFormat; - return this; - } - - public String getStreamMode() { - return streamMode; - } - - public StreamHttpNodeData setStreamMode(String streamMode) { - this.streamMode = streamMode; - return this; - } - - public String getDelimiter() { - return delimiter; - } - - public StreamHttpNodeData setDelimiter(String delimiter) { - this.delimiter = delimiter; - return this; - } - - public String getOutputKey() { - return outputKey; - } - - public StreamHttpNodeData setOutputKey(String outputKey) { - this.outputKey = outputKey; - return this; - } - - public Integer getTimeout() { - return timeout; - } - - public StreamHttpNodeData setTimeout(Integer timeout) { - this.timeout = timeout; - return this; - } - - public String getAuthorization() { - return authorization; - } - - public StreamHttpNodeData setAuthorization(String authorization) { - this.authorization = authorization; - return this; - } - - public String getAuthType() { - return authType; - } - - public StreamHttpNodeData setAuthType(String authType) { - this.authType = authType; - return this; - } - -} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java deleted file mode 100644 index bcb99571b5..0000000000 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverter.java +++ /dev/null @@ -1,314 +0,0 @@ -/* - * Copyright 2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.alibaba.cloud.ai.studio.admin.generator.service.dsl.converter; - -import java.util.Collections; -import java.util.LinkedHashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.function.BiConsumer; -import java.util.stream.Collectors; -import java.util.stream.Stream; - -import com.alibaba.cloud.ai.studio.admin.generator.model.VariableSelector; -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeType; -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata.StreamHttpNodeData; -import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.AbstractNodeDataConverter; -import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.DSLDialectType; -import com.fasterxml.jackson.core.JsonProcessingException; - -import org.springframework.stereotype.Component; - -@Component -public class StreamHttpNodeDataConverter extends AbstractNodeDataConverter { - - @Override - public Boolean supportNodeType(NodeType nodeType) { - return NodeType.STREAM_HTTP.equals(nodeType); - } - - @Override - protected List> getDialectConverters() { - return Stream.of(StreamHttpNodeDialectConverter.values()) - .map(StreamHttpNodeDialectConverter::dialectConverter) - .collect(Collectors.toList()); - } - - private enum StreamHttpNodeDialectConverter { - - DIFY(new DialectConverter<>() { - @Override - public Boolean supportDialect(DSLDialectType dialect) { - return DSLDialectType.DIFY.equals(dialect); - } - - @SuppressWarnings("unchecked") - @Override - public StreamHttpNodeData parse(Map data) throws JsonProcessingException { - List inputs = Optional.ofNullable((List) data.get("variable_selector")) - .filter(list -> list.size() == 2) - .map(list -> Collections.singletonList(new VariableSelector(list.get(0), list.get(1)))) - .orElse(Collections.emptyList()); - - List outputs = List.of(); - - String method = (String) data.getOrDefault("method", "GET"); - String url = (String) data.get("url"); - - // Parse headers - Map headers = Optional.ofNullable((Map) data.get("headers")) - .orElse(Collections.emptyMap()); - - // Parse body - Map body = Optional.ofNullable((Map) data.get("body")) - .orElse(Collections.emptyMap()); - - // Parse streaming configuration - String streamFormat = (String) data.getOrDefault("stream_format", "SSE"); - String streamMode = (String) data.getOrDefault("stream_mode", "DISTRIBUTE"); - String delimiter = (String) data.getOrDefault("delimiter", "\n"); - String outputKey = (String) data.get("output_key"); - Integer timeout = Optional.ofNullable((Integer) data.get("timeout")).orElse(30000); - - // Parse authentication - String authorization = (String) data.get("authorization"); - String authType = (String) data.get("auth_type"); - - StreamHttpNodeData nodeData = new StreamHttpNodeData(inputs, outputs); - nodeData.setMethod(method) - .setUrl(url) - .setHeaders(headers) - .setBody(body) - .setStreamFormat(streamFormat) - .setStreamMode(streamMode) - .setDelimiter(delimiter) - .setOutputKey(outputKey) - .setTimeout(timeout) - .setAuthorization(authorization) - .setAuthType(authType); - - return nodeData; - } - - @Override - public Map dump(StreamHttpNodeData nodeData) { - Map result = new LinkedHashMap<>(); - - // Variable selector - if (!nodeData.getInputs().isEmpty()) { - VariableSelector selector = nodeData.getInputs().get(0); - result.put("variable_selector", List.of(selector.getNamespace(), selector.getName())); - } - - // HTTP configuration - if (!"GET".equals(nodeData.getMethod())) { - result.put("method", nodeData.getMethod()); - } - if (nodeData.getUrl() != null) { - result.put("url", nodeData.getUrl()); - } - if (nodeData.getHeaders() != null && !nodeData.getHeaders().isEmpty()) { - result.put("headers", nodeData.getHeaders()); - } - if (nodeData.getBody() != null && !nodeData.getBody().isEmpty()) { - result.put("body", nodeData.getBody()); - } - - // Streaming configuration - if (!"SSE".equals(nodeData.getStreamFormat())) { - result.put("stream_format", nodeData.getStreamFormat()); - } - if (!"DISTRIBUTE".equals(nodeData.getStreamMode())) { - result.put("stream_mode", nodeData.getStreamMode()); - } - if (!"\n".equals(nodeData.getDelimiter())) { - result.put("delimiter", nodeData.getDelimiter()); - } - if (nodeData.getOutputKey() != null) { - result.put("output_key", nodeData.getOutputKey()); - } - if (nodeData.getTimeout() != null && !nodeData.getTimeout().equals(30000)) { - result.put("timeout", nodeData.getTimeout()); - } - - // Authentication - if (nodeData.getAuthorization() != null) { - result.put("authorization", nodeData.getAuthorization()); - } - if (nodeData.getAuthType() != null) { - result.put("auth_type", nodeData.getAuthType()); - } - - return result; - } - }), - - STUDIO(new DialectConverter<>() { - @Override - public Boolean supportDialect(DSLDialectType dialect) { - return DSLDialectType.STUDIO.equals(dialect); - } - - @SuppressWarnings("unchecked") - @Override - public StreamHttpNodeData parse(Map data) throws JsonProcessingException { - // Studio format parsing - more structured format - List inputs = Collections.emptyList(); - List outputs = List.of(); - - // Parse from config.node_param structure - Map nodeParam = (Map) data.get("node_param"); - if (nodeParam == null) { - nodeParam = data; // fallback to root level - } - - String method = (String) nodeParam.getOrDefault("method", "GET"); - String url = (String) nodeParam.get("url"); - - Map headers = Optional.ofNullable((Map) nodeParam.get("headers")) - .orElse(Collections.emptyMap()); - - Map body = Optional.ofNullable((Map) nodeParam.get("body")) - .orElse(Collections.emptyMap()); - - String streamFormat = (String) nodeParam.getOrDefault("streamFormat", "SSE"); - String streamMode = (String) nodeParam.getOrDefault("streamMode", "DISTRIBUTE"); - String delimiter = (String) nodeParam.getOrDefault("delimiter", "\n"); - String outputKey = (String) nodeParam.get("outputKey"); - Integer timeout = Optional.ofNullable((Integer) nodeParam.get("timeout")).orElse(30000); - - String authorization = (String) nodeParam.get("authorization"); - String authType = (String) nodeParam.get("authType"); - - StreamHttpNodeData nodeData = new StreamHttpNodeData(inputs, outputs); - nodeData.setMethod(method) - .setUrl(url) - .setHeaders(headers) - .setBody(body) - .setStreamFormat(streamFormat) - .setStreamMode(streamMode) - .setDelimiter(delimiter) - .setOutputKey(outputKey) - .setTimeout(timeout) - .setAuthorization(authorization) - .setAuthType(authType); - - return nodeData; - } - - @Override - public Map dump(StreamHttpNodeData nodeData) { - Map result = new LinkedHashMap<>(); - Map nodeParam = new LinkedHashMap<>(); - - // HTTP configuration - nodeParam.put("method", nodeData.getMethod()); - if (nodeData.getUrl() != null) { - nodeParam.put("url", nodeData.getUrl()); - } - if (nodeData.getHeaders() != null) { - nodeParam.put("headers", nodeData.getHeaders()); - } - if (nodeData.getBody() != null) { - nodeParam.put("body", nodeData.getBody()); - } - - // Streaming configuration - nodeParam.put("streamFormat", nodeData.getStreamFormat()); - nodeParam.put("streamMode", nodeData.getStreamMode()); - nodeParam.put("delimiter", nodeData.getDelimiter()); - if (nodeData.getOutputKey() != null) { - nodeParam.put("outputKey", nodeData.getOutputKey()); - } - nodeParam.put("timeout", nodeData.getTimeout()); - - // Authentication - if (nodeData.getAuthorization() != null) { - nodeParam.put("authorization", nodeData.getAuthorization()); - } - if (nodeData.getAuthType() != null) { - nodeParam.put("authType", nodeData.getAuthType()); - } - - result.put("node_param", nodeParam); - return result; - } - }), - - CUSTOM(defaultCustomDialectConverter(StreamHttpNodeData.class)); - - private final DialectConverter converter; - - StreamHttpNodeDialectConverter(DialectConverter converter) { - this.converter = converter; - } - - public DialectConverter dialectConverter() { - return this.converter; - } - - } - - @Override - public String generateVarName(int count) { - return "streamHttpNode" + count; - } - - @Override - public BiConsumer> postProcessConsumer(DSLDialectType dialectType) { - return switch (dialectType) { - case DIFY -> emptyProcessConsumer().andThen((streamHttpNodeData, idToVarName) -> { - // Set output key - streamHttpNodeData.setOutputKey( - streamHttpNodeData.getVarName() + "_" + StreamHttpNodeData.getDefaultOutputSchema().getName()); - streamHttpNodeData.setOutputs(List.of(StreamHttpNodeData.getDefaultOutputSchema())); - }).andThen(super.postProcessConsumer(dialectType)).andThen((streamHttpNodeData, idToVarName) -> { - // Convert Dify variable templates to SAA intermediate variables - if (streamHttpNodeData.getHeaders() != null) { - Map convertedHeaders = streamHttpNodeData.getHeaders() - .entrySet() - .stream() - .collect(Collectors.toMap( - entry -> this.convertVarTemplate(dialectType, entry.getKey().replace("{{#", "${{#"), - idToVarName), - entry -> this.convertVarTemplate(dialectType, entry.getValue().replace("{{#", "${{#"), - idToVarName), - (oldVal, newVal) -> newVal)); - streamHttpNodeData.setHeaders(convertedHeaders); - } - - // Convert URL template variables - if (streamHttpNodeData.getUrl() != null) { - String convertedUrl = this.convertVarTemplate(dialectType, - streamHttpNodeData.getUrl().replace("{{#", "${{#"), idToVarName); - streamHttpNodeData.setUrl(convertedUrl); - } - }); - case STUDIO -> emptyProcessConsumer().andThen((streamHttpNodeData, idToVarName) -> { - // Set output key for Studio format - if (streamHttpNodeData.getOutputKey() == null) { - streamHttpNodeData.setOutputKey(streamHttpNodeData.getVarName() + "_" - + StreamHttpNodeData.getDefaultOutputSchema().getName()); - } - streamHttpNodeData.setOutputs(List.of(StreamHttpNodeData.getDefaultOutputSchema())); - }).andThen(super.postProcessConsumer(dialectType)); - default -> super.postProcessConsumer(dialectType); - }; - } - -} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java deleted file mode 100644 index 505765f281..0000000000 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/service/generator/workflow/sections/StreamHttpNodeSection.java +++ /dev/null @@ -1,181 +0,0 @@ -/* - * Copyright 2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.alibaba.cloud.ai.studio.admin.generator.service.generator.workflow.sections; - -import java.util.List; -import java.util.Map; - -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.Node; -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeType; -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata.StreamHttpNodeData; -import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.DSLDialectType; -import com.alibaba.cloud.ai.studio.admin.generator.service.generator.workflow.NodeSection; - -import org.springframework.stereotype.Component; - -@Component -public class StreamHttpNodeSection implements NodeSection { - - @Override - public boolean support(NodeType nodeType) { - return NodeType.STREAM_HTTP.equals(nodeType); - } - - @Override - public String render(Node node, String varName) { - StreamHttpNodeData d = (StreamHttpNodeData) node.getData(); - String id = node.getId(); - StringBuilder sb = new StringBuilder(); - - sb.append(String.format("// —— StreamHttpNode [%s] ——%n", id)); - sb.append( - String.format("StreamHttpNodeParam.Builder %sParamBuilder = StreamHttpNodeParam.builder()%n", varName)); - sb.append(".webClient(WebClient.create())\n"); - - // HTTP method - if (d.getMethod() != null && !"GET".equals(d.getMethod())) { - sb.append(String.format(".method(HttpMethod.%s)%n", d.getMethod().toUpperCase())); - } - - // URL - if (d.getUrl() != null) { - sb.append(String.format(".url(\"%s\")%n", escape(d.getUrl()))); - } - - // Headers - if (d.getHeaders() != null && !d.getHeaders().isEmpty()) { - sb.append(".headers(Map.of(\n"); - boolean first = true; - for (Map.Entry entry : d.getHeaders().entrySet()) { - if (!first) { - sb.append(",\n"); - } - sb.append(String.format(" \"%s\", \"%s\"", escape(entry.getKey()), escape(entry.getValue()))); - first = false; - } - sb.append("\n))\n"); - } - - // Stream format - if (d.getStreamFormat() != null && !"SSE".equals(d.getStreamFormat())) { - sb.append(String.format(".streamFormat(StreamHttpNodeParam.StreamFormat.%s)%n", d.getStreamFormat())); - } - - // Stream mode - if (d.getStreamMode() != null && !"DISTRIBUTE".equals(d.getStreamMode())) { - sb.append(String.format(".streamMode(StreamHttpNodeParam.StreamMode.%s)%n", d.getStreamMode())); - } - - // Delimiter - if (d.getDelimiter() != null && !"\n".equals(d.getDelimiter())) { - sb.append(String.format(".delimiter(\"%s\")%n", escape(d.getDelimiter()))); - } - - // Output key - if (d.getOutputKey() != null) { - sb.append(String.format(".outputKey(\"%s\")%n", escape(d.getOutputKey()))); - } - - // Timeout - if (d.getTimeout() != null && !d.getTimeout().equals(30000)) { - sb.append(String.format(".readTimeout(Duration.ofMillis(%d))%n", d.getTimeout())); - } - - sb.append(";\n"); - - // Create StreamHttpNode - sb.append(String.format("StreamHttpNode %s = new StreamHttpNode(%sParamBuilder.build());%n", varName, varName)); - - // Add to state graph as async node since it's streaming - String assistNodeCode = String.format("wrapperStreamHttpNodeAction(%s, \"%s\")", varName, varName); - sb.append(String.format("stateGraph.addNode(\"%s\", AsyncNodeAction.node_async(%s));%n%n", varName, - assistNodeCode)); - - return sb.toString(); - } - - @Override - public String assistMethodCode(DSLDialectType dialectType) { - return switch (dialectType) { - case DIFY -> """ - private NodeAction wrapperStreamHttpNodeAction(StreamHttpNode streamHttpNode, String varName) { - return state -> { - try { - Flux> resultFlux = streamHttpNode.executeStreaming(state); - List> results = resultFlux.collectList().block(); - - Map output = new HashMap<>(); - if (results != null && !results.isEmpty()) { - output.put(varName + "_data", results); - output.put(varName + "_status", "success"); - output.put(varName + "_count", results.size()); - } else { - output.put(varName + "_data", Collections.emptyList()); - output.put(varName + "_status", "empty"); - output.put(varName + "_count", 0); - } - return output; - } catch (Exception e) { - return Map.of( - varName + "_data", Collections.emptyList(), - varName + "_status", "error", - varName + "_error", e.getMessage() - ); - } - }; - } - """; - case STUDIO -> """ - private NodeAction wrapperStreamHttpNodeAction(StreamHttpNode streamHttpNode, String varName) { - return state -> { - try { - Flux> resultFlux = streamHttpNode.executeStreaming(state); - List> results = resultFlux.collectList().block(); - - Map output = new HashMap<>(); - if (results != null && !results.isEmpty()) { - output.put("data", results); - output.put("status", "success"); - } else { - output.put("data", Collections.emptyList()); - output.put("status", "empty"); - } - return output; - } catch (Exception e) { - return Map.of( - "data", Collections.emptyList(), - "status", "error", - "error", e.getMessage() - ); - } - }; - } - """; - default -> ""; - }; - } - - @Override - public List getImports() { - return List.of("com.alibaba.cloud.ai.graph.node.StreamHttpNode", - "com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam", - "org.springframework.web.reactive.function.client.WebClient", "org.springframework.http.HttpMethod", - "reactor.core.publisher.Flux", "java.time.Duration", "java.util.Map", "java.util.HashMap", - "java.util.List", "java.util.Collections"); - } - -} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java deleted file mode 100644 index 70bacc1304..0000000000 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/test/java/com/alibaba/cloud/ai/studio/admin/generator/service/dsl/converter/StreamHttpNodeDataConverterTest.java +++ /dev/null @@ -1,197 +0,0 @@ -/* - * Copyright 2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.alibaba.cloud.ai.studio.admin.generator.service.dsl.converter; - -import java.util.List; -import java.util.Map; - -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.NodeType; -import com.alibaba.cloud.ai.studio.admin.generator.model.workflow.nodedata.StreamHttpNodeData; -import com.alibaba.cloud.ai.studio.admin.generator.service.dsl.DSLDialectType; - -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.extension.ExtendWith; -import org.mockito.InjectMocks; -import org.mockito.junit.jupiter.MockitoExtension; - -import static org.assertj.core.api.Assertions.assertThat; - -@ExtendWith(MockitoExtension.class) -class StreamHttpNodeDataConverterTest { - - @InjectMocks - private StreamHttpNodeDataConverter converter; - - @Test - void shouldSupportStreamHttpNodeType() { - assertThat(converter.supportNodeType(NodeType.STREAM_HTTP)).isTrue(); - assertThat(converter.supportNodeType(NodeType.HTTP)).isFalse(); - assertThat(converter.supportNodeType(NodeType.LLM)).isFalse(); - } - - @Test - void shouldGenerateCorrectVarName() { - assertThat(converter.generateVarName(1)).isEqualTo("streamHttpNode1"); - assertThat(converter.generateVarName(5)).isEqualTo("streamHttpNode5"); - } - - @Test - void shouldParseDifyDSLFormat() throws Exception { - // Given - Map dslData = new java.util.HashMap<>(); - dslData.put("method", "POST"); - dslData.put("url", "https://api.example.com/stream"); - dslData.put("headers", Map.of("Authorization", "Bearer token123", "Content-Type", "application/json")); - dslData.put("body", Map.of("query", "test query")); - dslData.put("stream_format", "SSE"); - dslData.put("stream_mode", "DISTRIBUTE"); - dslData.put("delimiter", "\n"); - dslData.put("output_key", "stream_results"); - dslData.put("timeout", 60000); - dslData.put("authorization", "Bearer token123"); - dslData.put("auth_type", "BEARER"); - - // When - StreamHttpNodeData result = converter.parseMapData(dslData, DSLDialectType.DIFY); - - // Then - assertThat(result).isNotNull(); - assertThat(result.getMethod()).isEqualTo("POST"); - assertThat(result.getUrl()).isEqualTo("https://api.example.com/stream"); - assertThat(result.getHeaders()).containsEntry("Authorization", "Bearer token123"); - assertThat(result.getHeaders()).containsEntry("Content-Type", "application/json"); - assertThat(result.getBody()).containsEntry("query", "test query"); - assertThat(result.getStreamFormat()).isEqualTo("SSE"); - assertThat(result.getStreamMode()).isEqualTo("DISTRIBUTE"); - assertThat(result.getDelimiter()).isEqualTo("\n"); - assertThat(result.getOutputKey()).isEqualTo("stream_results"); - assertThat(result.getTimeout()).isEqualTo(60000); - assertThat(result.getAuthorization()).isEqualTo("Bearer token123"); - assertThat(result.getAuthType()).isEqualTo("BEARER"); - } - - @Test - void shouldDumpToDifyDSLFormat() throws Exception { - // Given - StreamHttpNodeData nodeData = new StreamHttpNodeData(List.of(), List.of()); - nodeData.setMethod("POST") - .setUrl("https://api.example.com/stream") - .setHeaders(Map.of("Authorization", "Bearer token123")) - .setBody(Map.of("query", "test query")) - .setStreamFormat("JSON_LINES") - .setStreamMode("AGGREGATE") - .setDelimiter("|") - .setOutputKey("results") - .setTimeout(45000) - .setAuthorization("Bearer token123") - .setAuthType("BEARER"); - - // When - Map result = converter.dumpMapData(nodeData, DSLDialectType.DIFY); - - // Then - assertThat(result).isNotNull(); - assertThat(result.get("method")).isEqualTo("POST"); - assertThat(result.get("url")).isEqualTo("https://api.example.com/stream"); - assertThat(result.get("headers")).isEqualTo(Map.of("Authorization", "Bearer token123")); - assertThat(result.get("body")).isEqualTo(Map.of("query", "test query")); - assertThat(result.get("stream_format")).isEqualTo("JSON_LINES"); - assertThat(result.get("stream_mode")).isEqualTo("AGGREGATE"); - assertThat(result.get("delimiter")).isEqualTo("|"); - assertThat(result.get("output_key")).isEqualTo("results"); - assertThat(result.get("timeout")).isEqualTo(45000); - assertThat(result.get("authorization")).isEqualTo("Bearer token123"); - assertThat(result.get("auth_type")).isEqualTo("BEARER"); - } - - @Test - void shouldParseStudioDSLFormat() throws Exception { - // Given - Map nodeParam = new java.util.HashMap<>(); - nodeParam.put("method", "GET"); - nodeParam.put("url", "https://api.example.com/events"); - nodeParam.put("headers", Map.of("Accept", "text/event-stream")); - nodeParam.put("streamFormat", "SSE"); - nodeParam.put("streamMode", "DISTRIBUTE"); - nodeParam.put("delimiter", "\n"); - nodeParam.put("outputKey", "events"); - nodeParam.put("timeout", 30000); - - Map dslData = Map.of("node_param", nodeParam); - - // When - StreamHttpNodeData result = converter.parseMapData(dslData, DSLDialectType.STUDIO); - - // Then - assertThat(result).isNotNull(); - assertThat(result.getMethod()).isEqualTo("GET"); - assertThat(result.getUrl()).isEqualTo("https://api.example.com/events"); - assertThat(result.getHeaders()).containsEntry("Accept", "text/event-stream"); - assertThat(result.getStreamFormat()).isEqualTo("SSE"); - assertThat(result.getStreamMode()).isEqualTo("DISTRIBUTE"); - assertThat(result.getOutputKey()).isEqualTo("events"); - assertThat(result.getTimeout()).isEqualTo(30000); - } - - @Test - void shouldDumpToStudioDSLFormat() throws Exception { - // Given - StreamHttpNodeData nodeData = new StreamHttpNodeData(List.of(), List.of()); - nodeData.setMethod("GET") - .setUrl("https://api.example.com/events") - .setHeaders(Map.of("Accept", "text/event-stream")) - .setStreamFormat("SSE") - .setStreamMode("DISTRIBUTE") - .setOutputKey("events") - .setTimeout(30000); - - // When - Map result = converter.dumpMapData(nodeData, DSLDialectType.STUDIO); - - // Then - assertThat(result).isNotNull(); - @SuppressWarnings("unchecked") - Map nodeParam = (Map) result.get("node_param"); - assertThat(nodeParam).isNotNull(); - assertThat(nodeParam.get("method")).isEqualTo("GET"); - assertThat(nodeParam.get("url")).isEqualTo("https://api.example.com/events"); - assertThat(nodeParam.get("headers")).isEqualTo(Map.of("Accept", "text/event-stream")); - assertThat(nodeParam.get("streamFormat")).isEqualTo("SSE"); - assertThat(nodeParam.get("streamMode")).isEqualTo("DISTRIBUTE"); - assertThat(nodeParam.get("outputKey")).isEqualTo("events"); - assertThat(nodeParam.get("timeout")).isEqualTo(30000); - } - - @Test - void shouldHandleDefaultValues() throws Exception { - // Given - minimal DSL data - Map dslData = Map.of("url", "https://api.example.com/stream"); - - // When - StreamHttpNodeData result = converter.parseMapData(dslData, DSLDialectType.DIFY); - - // Then - assertThat(result).isNotNull(); - assertThat(result.getMethod()).isEqualTo("GET"); // default - assertThat(result.getUrl()).isEqualTo("https://api.example.com/stream"); - assertThat(result.getStreamFormat()).isEqualTo("SSE"); // default - assertThat(result.getStreamMode()).isEqualTo("DISTRIBUTE"); // default - assertThat(result.getDelimiter()).isEqualTo("\n"); // default - assertThat(result.getTimeout()).isEqualTo(30000); // default - } - -} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java deleted file mode 100644 index de8c313400..0000000000 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/src/main/java/com/alibaba/cloud/ai/studio/core/workflow/processor/impl/StreamHttpExecuteProcessor.java +++ /dev/null @@ -1,214 +0,0 @@ -/* - * Copyright 2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.alibaba.cloud.ai.studio.core.workflow.processor.impl; - -import com.alibaba.cloud.ai.studio.runtime.domain.workflow.Edge; -import com.alibaba.cloud.ai.studio.runtime.domain.workflow.Node; -import com.alibaba.cloud.ai.studio.runtime.domain.workflow.NodeResult; -import com.alibaba.cloud.ai.studio.runtime.domain.workflow.NodeTypeEnum; -import com.alibaba.cloud.ai.studio.runtime.utils.JsonUtils; -import com.alibaba.cloud.ai.studio.core.config.CommonConfig; -import com.alibaba.cloud.ai.studio.core.base.manager.RedisManager; -import com.alibaba.cloud.ai.studio.core.workflow.WorkflowContext; -import com.alibaba.cloud.ai.studio.core.workflow.WorkflowInnerService; -import com.alibaba.cloud.ai.studio.core.workflow.processor.AbstractExecuteProcessor; -import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.node.StreamHttpNode; -import com.alibaba.cloud.ai.graph.node.StreamHttpNodeParam; -import com.fasterxml.jackson.annotation.JsonProperty; -import lombok.Data; -import lombok.extern.slf4j.Slf4j; -import org.jgrapht.graph.DirectedAcyclicGraph; -import org.springframework.ai.chat.memory.ChatMemory; -import org.springframework.http.HttpMethod; -import org.springframework.stereotype.Component; -import org.springframework.web.reactive.function.client.WebClient; -import reactor.core.publisher.Flux; - -import java.time.Duration; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -@Slf4j -@Component("StreamHttpExecuteProcessor") -public class StreamHttpExecuteProcessor extends AbstractExecuteProcessor { - - public StreamHttpExecuteProcessor(RedisManager redisManager, WorkflowInnerService workflowInnerService, - ChatMemory conversationChatMemory, CommonConfig commonConfig) { - super(redisManager, workflowInnerService, conversationChatMemory, commonConfig); - } - - /** - * Executes the StreamHttp node in the workflow - * @param graph The workflow graph - * @param node The StreamHttp node to execute - * @param context The workflow context - * @return NodeResult containing streaming call status and response - */ - @Override - public NodeResult innerExecute(DirectedAcyclicGraph graph, Node node, WorkflowContext context) { - - // Initialize and refresh context - NodeResult nodeResult = initNodeResultAndRefreshContext(node, context); - - try { - NodeParam config = JsonUtils.fromMap(node.getConfig().getNodeParam(), NodeParam.class); - - // Build StreamHttpNodeParam from config - StreamHttpNodeParam.Builder paramBuilder = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.valueOf(config.getMethod().toUpperCase())) - .url(replaceTemplateContent(config.getUrl(), context)) - .streamFormat(StreamHttpNodeParam.StreamFormat.valueOf(config.getStreamFormat())) - .streamMode(StreamHttpNodeParam.StreamMode.valueOf(config.getStreamMode())) - .delimiter(config.getDelimiter()) - .outputKey(config.getOutputKey()) - .readTimeout(Duration.ofMillis(config.getTimeout())); - - // Add headers if present - if (config.getHeaders() != null && !config.getHeaders().isEmpty()) { - Map headers = new HashMap<>(); - config.getHeaders().forEach(header -> { - String value = replaceTemplateContent(header.getValue(), context); - headers.put(header.getKey(), value); - }); - paramBuilder.headers(headers); - } - - // Add body if present (skip body configuration for now) - // TODO: Implement proper body configuration conversion - - StreamHttpNodeParam streamParam = paramBuilder.build(); - StreamHttpNode streamHttpNode = new StreamHttpNode(streamParam); - - // Create OverAllState from workflow context - OverAllState state = createOverAllState(context); - - // Execute streaming and collect results - Flux> resultFlux = streamHttpNode.executeStreaming(state); - - // For workflow integration, we need to collect the streaming results - // This is a blocking operation for workflow compatibility - List> results = resultFlux.collectList().block(); - - // Set results - Map output = new HashMap<>(); - if (results != null && !results.isEmpty()) { - if (config.getOutputKey() != null && !config.getOutputKey().isEmpty()) { - output.put(config.getOutputKey(), results); - } - else { - // If no output key specified, put results directly - if (results.size() == 1) { - output.putAll(results.get(0)); - } - else { - output.put("results", results); - } - } - } - - nodeResult.setOutput(JsonUtils.toJson(output)); - nodeResult.setNodeId(node.getId()); - nodeResult.setNodeType(node.getType()); - - log.info("StreamHttp node executed successfully, nodeId: {}, resultsCount: {}", node.getId(), - results != null ? results.size() : 0); - - } - catch (Exception e) { - log.error("StreamHttp node execution failed, nodeId: {}", node.getId(), e); - nodeResult.setNodeStatus(com.alibaba.cloud.ai.studio.runtime.domain.workflow.NodeStatusEnum.FAIL.getCode()); - nodeResult.setOutput(null); - nodeResult.setErrorInfo("StreamHttp node exception: " + e.getMessage()); - nodeResult.setError(com.alibaba.cloud.ai.studio.runtime.enums.ErrorCode.WORKFLOW_EXECUTE_ERROR - .toError("StreamHttp node exception: " + e.getMessage())); - } - - return nodeResult; - } - - @Override - public String getNodeType() { - return NodeTypeEnum.STREAM_HTTP.getCode(); - } - - @Override - public String getNodeDescription() { - return NodeTypeEnum.STREAM_HTTP.getDesc(); - } - - /** - * Create OverAllState from WorkflowContext - */ - private OverAllState createOverAllState(WorkflowContext context) { - Map stateData = new HashMap<>(); - // Copy variables from workflow context to state - if (context.getVariablesMap() != null) { - stateData.putAll(context.getVariablesMap()); - } - return new OverAllState(stateData); - } - - /** - * Node parameter configuration - */ - @Data - public static class NodeParam { - - @JsonProperty("method") - private String method = "GET"; - - @JsonProperty("url") - private String url; - - @JsonProperty("headers") - private List headers; - - @JsonProperty("body") - private Map body; - - @JsonProperty("streamFormat") - private String streamFormat = "SSE"; - - @JsonProperty("streamMode") - private String streamMode = "DISTRIBUTE"; - - @JsonProperty("delimiter") - private String delimiter = "\n"; - - @JsonProperty("outputKey") - private String outputKey; - - @JsonProperty("timeout") - private int timeout = 30000; // 30 seconds default - - @Data - public static class HeaderParam { - - @JsonProperty("key") - private String key; - - @JsonProperty("value") - private String value; - - } - - } - -} diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java index 1e6b403be7..3496be9878 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java @@ -25,7 +25,7 @@ public enum NodeTypeEnum { APP_CUSTOM("AppCustom", "自定义应用节点"), AGENT_GROUP("AgentGroup", "智能体组节点"), SCRIPT("Script", "脚本节点"), CLASSIFIER("Classifier", "问题分类节点"), LLM("LLM", "大模型节点"), COMPONENT("AppComponent", "应用组件节点"), JUDGE("Judge", "判断节点"), RETRIEVAL("Retrieval", "知识库节点"), API("API", "Api调用节点"), - STREAM_HTTP("StreamHttp", "流式HTTP节点"), PLUGIN("Plugin", "插件节点"), MCP("MCP", "MCP节点"), + PLUGIN("Plugin", "插件节点"), MCP("MCP", "MCP节点"), PARAMETER_EXTRACTOR("ParameterExtractor", "参数提取节点"), ITERATOR_START("IteratorStart", "循环体开始节点"), ITERATOR("Iterator", "循环节点"), ITERATOR_END("IteratorEnd", "循环体结束节点"), PARALLEL_START("ParallelStart", "批处理开始节点"), PARALLEL("Parallel", "批处理节点"), PARALLEL_END("ParallelEnd", "批处理结束节点"), END("End", "结束节点"); From 9ce538f92bb598fb15b28d8a48d2d8f96a7cd0fa Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Thu, 18 Sep 2025 15:01:00 +0800 Subject: [PATCH 04/11] fix(graph): ci bug --- .../ai/graph/streaming/StreamHttpNode.java | 21 ++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java index 0f3315265a..b4b3b29be9 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java @@ -66,13 +66,13 @@ public StreamHttpNode(StreamHttpNodeParam param) { public Flux> executeStreaming(OverAllState state) throws Exception { try { String finalUrl = replaceVariables(param.getUrl(), state); - validateUrl(finalUrl); // 添加URL安全验证 Map finalHeaders = replaceVariables(param.getHeaders(), state); Map finalQueryParams = replaceVariables(param.getQueryParams(), state); UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); finalQueryParams.forEach(uriBuilder::queryParam); - URI finalUri = uriBuilder.build().toUri(); + URI finalUri = uriBuilder.encode().build().toUri(); // 使用encode()进行URL编码 + validateUrl(finalUri.toString()); // 在编码后进行URL安全验证 WebClient.RequestBodySpec requestSpec = param.getWebClient() .method(param.getMethod()) @@ -193,9 +193,20 @@ private Flux parseJsonLinesChunk(String chunk) { catch (JsonProcessingException e) { logger.warn("Invalid JSON line: {}, error: {}", line, e.getMessage()); // 返回包含错误信息的特殊标记，保留原始数据用于调试 - String errorJson = String.format("{\"_parsing_error\": \"%s\", \"_raw_data\": \"%s\"}", - e.getMessage().replaceAll("\"", "\\\\\""), line.replaceAll("\"", "\\\\\"")); - results.add(errorJson); + try { + Map errorMap = new HashMap<>(); + errorMap.put("_parsing_error", e.getMessage()); + errorMap.put("_raw_data", line); + String errorJson = objectMapper.writeValueAsString(errorMap); + results.add(errorJson); + } + catch (JsonProcessingException jsonError) { + // 如果连错误JSON都无法生成，则使用简单的错误格式 + String errorJson = String.format( + "{\"_parsing_error\": \"JSON processing failed\", \"_raw_data\": \"%s\"}", + line.replaceAll("\"", "\\\\\"")); + results.add(errorJson); + } } } } From f1659aeb70f08633598ec7e37b0c45a1d76ca8cb Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Thu, 18 Sep 2025 17:16:17 +0800 Subject: [PATCH 05/11] feat(graph): fix ci bug --- .../alibaba/cloud/ai/graph/node/HttpNode.java | 2 +- .../ai/graph/streaming/StreamHttpNode.java | 86 ++++++++++--------- .../generator/model/workflow/NodeType.java | 11 ++- .../pom.xml | 6 -- 4 files changed, 52 insertions(+), 53 deletions(-) diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java index 6854c31ed6..aab21c0d63 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/HttpNode.java @@ -724,7 +724,7 @@ public boolean hasContent() { public static class AuthConfig { - public enum AuthType { + enum AuthType { BASIC, BEARER diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java index b4b3b29be9..132d9b94f2 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java @@ -71,8 +71,9 @@ public Flux> executeStreaming(OverAllState state) throws Exc UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); finalQueryParams.forEach(uriBuilder::queryParam); - URI finalUri = uriBuilder.encode().build().toUri(); // 使用encode()进行URL编码 - validateUrl(finalUri.toString()); // 在编码后进行URL安全验证 + URI finalUri = uriBuilder.build().toUri(); + + validateUrl(finalUri.toString()); // 添加URL安全验证，在URI构建之后 WebClient.RequestBodySpec requestSpec = param.getWebClient() .method(param.getMethod()) @@ -133,7 +134,12 @@ private Flux> processStreamResponse(Flux respons .buffer(param.getBufferTimeout()) // 使用配置的缓冲超时时间避免内存累积 .map(chunks -> String.join("", chunks)) .flatMap(this::parseStreamChunk) - .filter(data -> !data.isEmpty()) + .filter(data -> { + if (data instanceof String) { + return !((String) data).isEmpty(); + } + return data != null; // 对于Map对象，只要不为null就保留 + }) .map(this::wrapOutput) .transform(flux -> { if (param.getStreamMode() == StreamMode.AGGREGATE) { @@ -151,11 +157,11 @@ private Flux> processStreamResponse(Flux respons /** * 解析流数据块 */ - private Flux parseStreamChunk(String chunk) { + private Flux parseStreamChunk(String chunk) { return switch (param.getStreamFormat()) { - case SSE -> parseSSEChunk(chunk); + case SSE -> parseSSEChunk(chunk).cast(Object.class); case JSON_LINES -> parseJsonLinesChunk(chunk); - case TEXT_STREAM -> parseTextStreamChunk(chunk); + case TEXT_STREAM -> parseTextStreamChunk(chunk).cast(Object.class); }; } @@ -179,9 +185,9 @@ private Flux parseSSEChunk(String chunk) { /** * 解析JSON Lines格式数据 */ - private Flux parseJsonLinesChunk(String chunk) { + private Flux parseJsonLinesChunk(String chunk) { String[] lines = chunk.split("\n"); - List results = new ArrayList<>(); + List results = new ArrayList<>(); for (String line : lines) { line = line.trim(); @@ -192,21 +198,11 @@ private Flux parseJsonLinesChunk(String chunk) { } catch (JsonProcessingException e) { logger.warn("Invalid JSON line: {}, error: {}", line, e.getMessage()); - // 返回包含错误信息的特殊标记，保留原始数据用于调试 - try { - Map errorMap = new HashMap<>(); - errorMap.put("_parsing_error", e.getMessage()); - errorMap.put("_raw_data", line); - String errorJson = objectMapper.writeValueAsString(errorMap); - results.add(errorJson); - } - catch (JsonProcessingException jsonError) { - // 如果连错误JSON都无法生成，则使用简单的错误格式 - String errorJson = String.format( - "{\"_parsing_error\": \"JSON processing failed\", \"_raw_data\": \"%s\"}", - line.replaceAll("\"", "\\\\\"")); - results.add(errorJson); - } + // 返回包含错误信息的Map对象，用于直接处理 + Map errorMap = new HashMap<>(); + errorMap.put("_parsing_error", e.getMessage()); + errorMap.put("_raw_data", line); + results.add(errorMap); } } } @@ -234,20 +230,31 @@ private Flux parseTextStreamChunk(String chunk) { /** * 包装输出数据 */ - private Map wrapOutput(String data) { + private Map wrapOutput(Object data) { Map result = new HashMap<>(); - try { - if (data.startsWith("{") || data.startsWith("[")) { - JsonNode jsonNode = objectMapper.readTree(data); - Object parsedData = objectMapper.convertValue(jsonNode, Object.class); - result.put("data", parsedData); + if (data instanceof Map) { + // 如果已经是Map对象（如错误处理的结果），直接使用 + result.put("data", data); + } + else if (data instanceof String) { + String stringData = (String) data; + try { + if (stringData.startsWith("{") || stringData.startsWith("[")) { + JsonNode jsonNode = objectMapper.readTree(stringData); + Object parsedData = objectMapper.convertValue(jsonNode, Object.class); + result.put("data", parsedData); + } + else { + result.put("data", stringData); + } } - else { - result.put("data", data); + catch (JsonProcessingException e) { + result.put("data", stringData); } } - catch (JsonProcessingException e) { + else { + // 对于其他类型的数据，直接使用 result.put("data", data); } @@ -327,6 +334,7 @@ private String replaceVariables(String template, OverAllState state) { String key = matcher.group(1); Object value = state.value(key).orElse(""); String replacement = value != null ? value.toString() : ""; + // 不进行编码，让UriComponentsBuilder处理 matcher.appendReplacement(result, Matcher.quoteReplacement(replacement)); } @@ -348,14 +356,12 @@ private Map replaceVariables(Map map, OverAllSta */ private void applyAuth(WebClient.RequestBodySpec requestSpec) { if (param.getAuthConfig() != null) { - switch (param.getAuthConfig().getType()) { - case BASIC: - requestSpec.headers(headers -> headers.setBasicAuth(param.getAuthConfig().getUsername(), - param.getAuthConfig().getPassword())); - break; - case BEARER: - requestSpec.headers(headers -> headers.setBearerAuth(param.getAuthConfig().getToken())); - break; + if (param.getAuthConfig().isBasic()) { + requestSpec.headers(headers -> headers.setBasicAuth(param.getAuthConfig().getUsername(), + param.getAuthConfig().getPassword())); + } + else if (param.getAuthConfig().isBearer()) { + requestSpec.headers(headers -> headers.setBearerAuth(param.getAuthConfig().getToken())); } } } diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java index 91d601d667..6fefead060 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java @@ -18,7 +18,6 @@ import java.util.Arrays; import java.util.Optional; -// TODO: 将枚举类的DSL Value字段改为Function public enum NodeType { START("start", "start", "Start"), @@ -39,23 +38,23 @@ public enum NodeType { AGGREGATOR("aggregator", "variable-aggregator", "UNSUPPORTED"), - HUMAN("human", "UNSUPPORTED", "UNSUPPORTED"), + HUMAN("human", "unsupported", "UNSUPPORTED"), - BRANCH("branch", "if-else", "Judge"), + BRANCH("branch", "if-else", "UNSUPPORTED"), DOC_EXTRACTOR("document-extractor", "document-extractor", "UNSUPPORTED"), - QUESTION_CLASSIFIER("question-classifier", "question-classifier", "Classifier"), + QUESTION_CLASSIFIER("question-classifier", "question-classifier", "UNSUPPORTED"), HTTP("http", "http-request", "UNSUPPORTED"), LIST_OPERATOR("list-operator", "list-operator", "UNSUPPORTED"), - PARAMETER_PARSING("parameter-parsing", "parameter-extractor", "ParameterExtractor"), + PARAMETER_PARSING("parameter-parsing", "parameter-extractor", "UNSUPPORTED"), TOOL("tool", "tool", "UNSUPPORTED"), - MCP("mcp", "UNSUPPORTED", "UNSUPPORTED"), + MCP("mcp", "unsupported", "UNSUPPORTED"), TEMPLATE_TRANSFORM("template-transform", "template-transform", "UNSUPPORTED"), diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml index 1335c5cca2..4723ea7d14 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-core/pom.xml @@ -94,12 +94,6 @@ spring-ai-alibaba-core - - com.alibaba.cloud.ai - spring-ai-alibaba-graph-core - ${project.version} - - io.netty netty-resolver-dns-native-macos From 29003bdffed56f5470df641b4b464c886c274836 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Thu, 18 Sep 2025 20:14:02 +0800 Subject: [PATCH 06/11] fix ci bug --- .../ai/graph/streaming/StreamHttpNodeTest.java | 13 +++++++++++++ .../admin/generator/model/workflow/NodeType.java | 11 ++++++----- .../runtime/domain/workflow/NodeTypeEnum.java | 10 +++++----- 3 files changed, 24 insertions(+), 10 deletions(-) diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java index 3e0a4e113b..ce01fddfa7 100644 --- a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java +++ b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java @@ -95,6 +95,7 @@ void testSSEStreamProcessing() throws Exception { .streamFormat(StreamFormat.SSE) .streamMode(StreamMode.DISTRIBUTE) .outputKey("sse_output") + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -139,6 +140,7 @@ void testJsonLinesStreamProcessing() throws Exception { .streamMode(StreamMode.DISTRIBUTE) .outputKey("jsonlines_output") .readTimeout(Duration.ofSeconds(10)) + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -179,6 +181,7 @@ void testTextStreamProcessing() throws Exception { .streamMode(StreamMode.DISTRIBUTE) .delimiter("\n") .outputKey("text_output") + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -220,6 +223,7 @@ void testAggregateMode() throws Exception { .streamFormat(StreamFormat.JSON_LINES) .streamMode(StreamMode.AGGREGATE) .outputKey("aggregated_output") + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -262,6 +266,7 @@ void testVariableReplacement() throws Exception { .streamFormat(StreamFormat.JSON_LINES) .streamMode(StreamMode.DISTRIBUTE) .outputKey("variable_output") + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -295,6 +300,7 @@ void testErrorHandling() throws Exception { .streamMode(StreamMode.DISTRIBUTE) .outputKey("error_output") .readTimeout(Duration.ofSeconds(2)) // 短超时 + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -340,6 +346,7 @@ void testWithoutOutputKey() throws Exception { .url(mockWebServer.url("/no-key").toString()) .streamFormat(StreamFormat.SSE) .streamMode(StreamMode.DISTRIBUTE) + .allowInternalAddress(true) // 允许访问localhost // 不设置outputKey .build(); @@ -379,6 +386,7 @@ void testStateGraphIntegration() throws Exception { .streamMode(StreamMode.DISTRIBUTE) .outputKey("chat_response") .header("Content-Type", "application/json") + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -437,6 +445,7 @@ void testStreamingWithHeaders() throws Exception { .header("Authorization", "Bearer ${test_key}") .header("X-User-Agent", "StreamHttpNode/1.0") .readTimeout(Duration.ofSeconds(30)) + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -516,6 +525,7 @@ void testSimpleHttpRequest() throws Exception { .streamMode(StreamMode.AGGREGATE) .outputKey("simple_output") .readTimeout(Duration.ofSeconds(5)) // 短超时 + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -602,6 +612,7 @@ void testJsonLinesWithErrorHandling() throws Exception { .url(mockWebServer.url("/jsonlines-error").toString()) .streamFormat(StreamFormat.JSON_LINES) .streamMode(StreamMode.DISTRIBUTE) + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -648,6 +659,7 @@ void testCustomBufferTimeout() throws Exception { .streamFormat(StreamFormat.JSON_LINES) .streamMode(StreamMode.DISTRIBUTE) .bufferTimeout(Duration.ofMillis(50)) // 自定义缓冲超时 + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); @@ -699,6 +711,7 @@ void testStructuredErrorLogging() throws Exception { .url(mockWebServer.url("/error").toString()) .streamFormat(StreamFormat.JSON_LINES) .streamMode(StreamMode.DISTRIBUTE) + .allowInternalAddress(true) // 允许访问localhost .build(); streamHttpNode = new StreamHttpNode(param); diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java index ec277af0f5..1b1ab78d0c 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-admin/src/main/java/com/alibaba/cloud/ai/studio/admin/generator/model/workflow/NodeType.java @@ -18,6 +18,7 @@ import java.util.Arrays; import java.util.Optional; +// TODO: 将枚举类的DSL Value字段改为Function public enum NodeType { START("start", "start", "Start"), @@ -38,19 +39,19 @@ public enum NodeType { AGGREGATOR("aggregator", "variable-aggregator", "UNSUPPORTED"), - HUMAN("human", "unsupported", "UNSUPPORTED"), + HUMAN("human", "UNSUPPORTED", "UNSUPPORTED"), - BRANCH("branch", "if-else", "UNSUPPORTED"), + BRANCH("branch", "if-else", "Judge"), DOC_EXTRACTOR("document-extractor", "document-extractor", "UNSUPPORTED"), - QUESTION_CLASSIFIER("question-classifier", "question-classifier", "UNSUPPORTED"), + QUESTION_CLASSIFIER("question-classifier", "question-classifier", "Classifier"), HTTP("http", "http-request", "API"), LIST_OPERATOR("list-operator", "list-operator", "UNSUPPORTED"), - PARAMETER_PARSING("parameter-parsing", "parameter-extractor", "UNSUPPORTED"), + PARAMETER_PARSING("parameter-parsing", "parameter-extractor", "ParameterExtractor"), TOOL("tool", "tool", "UNSUPPORTED"), @@ -67,7 +68,7 @@ public enum NodeType { ITERATION_END("iteration-end", "iteration-end", "ParallelEnd"), - ASSIGNER("assigner", "assigner", "UNSUPPORTED"); + ASSIGNER("assigner", "assigner", "VariableAssign"); private final String value; diff --git a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java index 3496be9878..f10b5a63a9 100644 --- a/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java +++ b/spring-ai-alibaba-studio/spring-ai-alibaba-studio-server/spring-ai-alibaba-studio-server-runtime/src/main/java/com/alibaba/cloud/ai/studio/runtime/domain/workflow/NodeTypeEnum.java @@ -24,11 +24,11 @@ public enum NodeTypeEnum { VARIABLE_ASSIGN("VariableAssign", "变量赋值节点"), VARIABLE_HANDLE("VariableHandle", "变量处理节点"), APP_CUSTOM("AppCustom", "自定义应用节点"), AGENT_GROUP("AgentGroup", "智能体组节点"), SCRIPT("Script", "脚本节点"), CLASSIFIER("Classifier", "问题分类节点"), LLM("LLM", "大模型节点"), COMPONENT("AppComponent", "应用组件节点"), - JUDGE("Judge", "判断节点"), RETRIEVAL("Retrieval", "知识库节点"), API("API", "Api调用节点"), - PLUGIN("Plugin", "插件节点"), MCP("MCP", "MCP节点"), - PARAMETER_EXTRACTOR("ParameterExtractor", "参数提取节点"), ITERATOR_START("IteratorStart", "循环体开始节点"), - ITERATOR("Iterator", "循环节点"), ITERATOR_END("IteratorEnd", "循环体结束节点"), PARALLEL_START("ParallelStart", "批处理开始节点"), - PARALLEL("Parallel", "批处理节点"), PARALLEL_END("ParallelEnd", "批处理结束节点"), END("End", "结束节点"); + JUDGE("Judge", "判断节点"), RETRIEVAL("Retrieval", "知识库节点"), API("API", "Api调用节点"), PLUGIN("Plugin", "插件节点"), + MCP("MCP", "MCP节点"), PARAMETER_EXTRACTOR("ParameterExtractor", "参数提取节点"), + ITERATOR_START("IteratorStart", "循环体开始节点"), ITERATOR("Iterator", "循环节点"), ITERATOR_END("IteratorEnd", "循环体结束节点"), + PARALLEL_START("ParallelStart", "批处理开始节点"), PARALLEL("Parallel", "批处理节点"), PARALLEL_END("ParallelEnd", "批处理结束节点"), + END("End", "结束节点"); private final String code; From cbfdec9361ea67511ae75d0d851c1e2cd939b3ed Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Fri, 19 Sep 2025 19:07:17 +0800 Subject: [PATCH 07/11] fix: use AsyncNodeAction --- spring-ai-alibaba-graph-core/pom.xml | 1 + .../ai/graph/streaming/StreamHttpNode.java | 159 ++++++++++++------ .../graph/streaming/StreamHttpNodeTest.java | 82 +++++++-- 3 files changed, 173 insertions(+), 69 deletions(-) diff --git a/spring-ai-alibaba-graph-core/pom.xml b/spring-ai-alibaba-graph-core/pom.xml index 8711a964e1..7b8e641b8b 100644 --- a/spring-ai-alibaba-graph-core/pom.xml +++ b/spring-ai-alibaba-graph-core/pom.xml @@ -51,6 +51,7 @@ org.springframework spring-webflux + provided diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java index 132d9b94f2..6141144b59 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java @@ -16,7 +16,8 @@ package com.alibaba.cloud.ai.graph.streaming; import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.action.StreamingGraphNode; +import com.alibaba.cloud.ai.graph.action.AsyncNodeAction; +import com.alibaba.cloud.ai.graph.async.AsyncGenerator; import com.alibaba.cloud.ai.graph.exception.GraphRunnerException; import com.alibaba.cloud.ai.graph.exception.RunnableErrors; import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamMode; @@ -41,12 +42,13 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.CompletableFuture; import java.util.regex.Matcher; import java.util.regex.Pattern; import static com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamFormat.*; -public class StreamHttpNode implements StreamingGraphNode { +public class StreamHttpNode implements AsyncNodeAction { private static final Logger logger = LoggerFactory.getLogger(StreamHttpNode.class); @@ -63,65 +65,116 @@ public StreamHttpNode(StreamHttpNodeParam param) { } @Override - public Flux> executeStreaming(OverAllState state) throws Exception { + public CompletableFuture> apply(OverAllState state) { try { - String finalUrl = replaceVariables(param.getUrl(), state); - Map finalHeaders = replaceVariables(param.getHeaders(), state); - Map finalQueryParams = replaceVariables(param.getQueryParams(), state); - - UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); - finalQueryParams.forEach(uriBuilder::queryParam); - URI finalUri = uriBuilder.build().toUri(); - - validateUrl(finalUri.toString()); // 添加URL安全验证，在URI构建之后 - - WebClient.RequestBodySpec requestSpec = param.getWebClient() - .method(param.getMethod()) - .uri(finalUri) - .headers(headers -> headers.setAll(finalHeaders)); - - applyAuth(requestSpec); - initBody(requestSpec, state); - - // 直接返回处理后的结果，将HTTP错误转换为错误数据项 - return requestSpec.exchangeToFlux(response -> { - if (!response.statusCode().is2xxSuccessful()) { - // 处理HTTP错误：将错误转换为包含错误信息的Map，作为数据项发射出去 - return response.bodyToMono(String.class) - .defaultIfEmpty("HTTP Error") // 如果响应体为空，使用默认错误信息 - .map(errorBody -> { - // 创建错误信息Map - WebClientResponseException exception = new WebClientResponseException( - response.statusCode().value(), "HTTP " + response.statusCode() + ": " + errorBody, - null, null, null); - return createErrorOutput(exception); - }) - .flux(); // 转换为Flux - } - - // 处理成功响应 - Flux dataBufferFlux = response.bodyToFlux(DataBuffer.class); - return processStreamResponse(dataBufferFlux, state); - }) - .retryWhen(Retry.backoff(param.getRetryConfig().getMaxRetries(), - Duration.ofMillis(param.getRetryConfig().getMaxRetryInterval()))) - .timeout(param.getReadTimeout()) - // 处理网络超时、连接错误等其他异常 - .onErrorResume(throwable -> { - logger.error("StreamHttpNode execution failed: url={}, method={}, error={}", finalUrl, - param.getMethod(), throwable.getMessage(), throwable); - return Flux.just(createErrorOutput(throwable)); - }); - + // 获取流式数据并转换为AsyncGenerator + Flux> streamFlux = executeStreaming(state); + + // 将Flux转换为AsyncGenerator，供图框架处理流式数据 + AsyncGenerator> generator = createAsyncGenerator(streamFlux); + + // 返回包含AsyncGenerator的结果Map + String outputKey = param.getOutputKey() != null ? param.getOutputKey() : "stream_output"; + return CompletableFuture.completedFuture(Map.of(outputKey, generator)); } catch (Exception e) { logger.error("StreamHttpNode initialization failed: url={}, method={}, error={}", param.getUrl(), param.getMethod(), e.getMessage(), e); - // 返回错误输出而不是抛出异常 - return Flux.just(createErrorOutput(e)); + // 返回包含错误信息的AsyncGenerator而不是直接返回Map + String outputKey = param.getOutputKey() != null ? param.getOutputKey() : "stream_output"; + Flux> errorFlux = Flux.just(createErrorOutput(e)); + AsyncGenerator> errorGenerator = createAsyncGenerator(errorFlux); + return CompletableFuture.completedFuture(Map.of(outputKey, errorGenerator)); } } + /** + * 执行流式HTTP请求 - 保持原有的流式逻辑 + * Package-private for testing + */ + Flux> executeStreaming(OverAllState state) throws Exception { + String finalUrl = replaceVariables(param.getUrl(), state); + Map finalHeaders = replaceVariables(param.getHeaders(), state); + Map finalQueryParams = replaceVariables(param.getQueryParams(), state); + + UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); + finalQueryParams.forEach(uriBuilder::queryParam); + URI finalUri = uriBuilder.build().toUri(); + + validateUrl(finalUri.toString()); // 添加URL安全验证，在URI构建之后 + + WebClient.RequestBodySpec requestSpec = param.getWebClient() + .method(param.getMethod()) + .uri(finalUri) + .headers(headers -> headers.setAll(finalHeaders)); + + applyAuth(requestSpec); + initBody(requestSpec, state); + + // 直接返回处理后的结果，将HTTP错误转换为错误数据项 + return requestSpec.exchangeToFlux(response -> { + if (!response.statusCode().is2xxSuccessful()) { + // 处理HTTP错误：将错误转换为包含错误信息的Map，作为数据项发射出去 + return response.bodyToMono(String.class) + .defaultIfEmpty("HTTP Error") // 如果响应体为空，使用默认错误信息 + .map(errorBody -> { + // 创建错误信息Map + WebClientResponseException exception = new WebClientResponseException( + response.statusCode().value(), "HTTP " + response.statusCode() + ": " + errorBody, + null, null, null); + return createErrorOutput(exception); + }) + .flux(); // 转换为Flux + } + + // 处理成功响应 + Flux dataBufferFlux = response.bodyToFlux(DataBuffer.class); + return processStreamResponse(dataBufferFlux, state); + }) + .retryWhen(Retry.backoff(param.getRetryConfig().getMaxRetries(), + Duration.ofMillis(param.getRetryConfig().getMaxRetryInterval()))) + .timeout(param.getReadTimeout()) + // 处理网络超时、连接错误等其他异常 + .onErrorResume(throwable -> { + logger.error("StreamHttpNode execution failed: url={}, method={}, error={}", finalUrl, + param.getMethod(), throwable.getMessage(), throwable); + return Flux.just(createErrorOutput(throwable)); + }); + } + + /** + * 将Flux转换为AsyncGenerator，供图框架处理流式数据 + */ + private AsyncGenerator> createAsyncGenerator(Flux> flux) { + return new AsyncGenerator>() { + private boolean completed = false; + private final java.util.concurrent.BlockingQueue>> queue = + new java.util.concurrent.LinkedBlockingQueue<>(); + + { + // 异步处理Flux数据 + flux.subscribe( + data -> queue.offer(AsyncGenerator.Data.of(CompletableFuture.completedFuture(data))), + error -> queue.offer(AsyncGenerator.Data.error(error)), + () -> { + completed = true; + queue.offer(AsyncGenerator.Data.done()); + } + ); + } + + @Override + public AsyncGenerator.Data> next() { + try { + return queue.take(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return AsyncGenerator.Data.error(e); + } + } + }; + } + /** * 处理流式响应数据 */ diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java index ce01fddfa7..4909ef62eb 100644 --- a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java +++ b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java @@ -17,6 +17,7 @@ import com.alibaba.cloud.ai.graph.OverAllState; import com.alibaba.cloud.ai.graph.OverAllStateBuilder; +import com.alibaba.cloud.ai.graph.async.AsyncGenerator; import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamFormat; import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamMode; import okhttp3.mockwebserver.MockResponse; @@ -36,6 +37,7 @@ import java.time.Duration; import java.util.List; import java.util.Map; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.TimeUnit; import static org.assertj.core.api.Assertions.assertThat; @@ -100,7 +102,10 @@ void testSSEStreamProcessing() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("sse_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("sse_output"); @@ -145,7 +150,10 @@ void testJsonLinesStreamProcessing() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("jsonlines_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("jsonlines_output"); @@ -186,7 +194,10 @@ void testTextStreamProcessing() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("text_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("text_output"); @@ -228,7 +239,10 @@ void testAggregateMode() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("aggregated_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("aggregated_output"); @@ -271,7 +285,10 @@ void testVariableReplacement() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("variable_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("variable_output"); @@ -305,7 +322,10 @@ void testErrorHandling() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("error_output"); + Flux> result = Flux.fromStream(generator.stream()); // 期望收到包含错误信息的输出 StepVerifier.create(result).assertNext(output -> { @@ -352,7 +372,10 @@ void testWithoutOutputKey() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { // 没有outputKey时，直接返回数据 @@ -392,7 +415,10 @@ void testStateGraphIntegration() throws Exception { streamHttpNode = new StreamHttpNode(param); // 测试流式执行 - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("chat_response"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("chat_response"); @@ -450,7 +476,10 @@ void testStreamingWithHeaders() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_data"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result).assertNext(output -> { assertThat(output).containsKey("stream_data"); @@ -530,7 +559,10 @@ void testSimpleHttpRequest() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("simple_output"); + Flux> result = Flux.fromStream(generator.stream()); // 使用timeout()确保不会无限等待 StepVerifier.create(result.timeout(Duration.ofSeconds(10))).assertNext(output -> { @@ -555,7 +587,10 @@ void testUrlValidation_ShouldRejectInternalAddress() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { // 验证返回错误信息 @@ -583,7 +618,10 @@ void testUrlValidation_ShouldAllowInternalAddressWhenConfigured() throws Excepti streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { // 验证正常处理 @@ -617,7 +655,10 @@ void testJsonLinesWithErrorHandling() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { // 第一个有效JSON @@ -664,7 +705,10 @@ void testCustomBufferTimeout() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { assertThat(output).containsKey("data"); @@ -690,7 +734,10 @@ void testInvalidProtocolValidation() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { // 验证返回错误信息 @@ -716,7 +763,10 @@ void testStructuredErrorLogging() throws Exception { streamHttpNode = new StreamHttpNode(param); - Flux> result = streamHttpNode.executeStreaming(testState); + CompletableFuture> future = streamHttpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { // 验证错误输出格式 From d6a112fcb2e9446ae6f4d570f75c313ea56cb102 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Fri, 19 Sep 2025 19:50:49 +0800 Subject: [PATCH 08/11] del ara --- spring-ai-alibaba-graph-core/pom.xml | 42 -------------- .../ai/graph/action/StreamingGraphNode.java | 52 ------------------ .../cloud/ai/graph/executor/NodeExecutor.java | 55 ------------------- 3 files changed, 149 deletions(-) delete mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java diff --git a/spring-ai-alibaba-graph-core/pom.xml b/spring-ai-alibaba-graph-core/pom.xml index 7b8e641b8b..9d0536c5f8 100644 --- a/spring-ai-alibaba-graph-core/pom.xml +++ b/spring-ai-alibaba-graph-core/pom.xml @@ -58,58 +58,16 @@ io.github.a2asdk a2a-java-reference-server ${a2a-sdk.version} - - - org.jboss.logging - jboss-logging - - - org.jboss.logmanager - jboss-logmanager - - - org.jboss.slf4j - slf4j-jboss-logmanager - - io.github.a2asdk a2a-java-sdk-server-common ${a2a-sdk.version} - - - org.jboss.logging - jboss-logging - - - org.jboss.logmanager - jboss-logmanager - - - org.jboss.slf4j - slf4j-jboss-logmanager - - io.github.a2asdk a2a-java-sdk-client ${a2a-sdk.version} - - - org.jboss.logging - jboss-logging - - - org.jboss.logmanager - jboss-logmanager - - - org.jboss.slf4j - slf4j-jboss-logmanager - - diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java deleted file mode 100644 index 24ba809fc3..0000000000 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/action/StreamingGraphNode.java +++ /dev/null @@ -1,52 +0,0 @@ -/* - * Copyright 2024-2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.alibaba.cloud.ai.graph.action; - -import com.alibaba.cloud.ai.graph.OverAllState; -import reactor.core.publisher.Flux; - -import java.util.Map; - -public interface StreamingGraphNode extends NodeAction { - - /** - * 执行流式节点操作，返回响应式数据流。 这是流式节点的核心方法，用于生成连续的数据流。 - * @param state 图的整体状态 - * @return 包含图输出数据的响应式流 - * @throws Exception 执行过程中可能出现的异常 - */ - Flux> executeStreaming(OverAllState state) throws Exception; - - /** - * 默认实现，通过流式方法的第一个元素来提供同步兼容性。 该方法确保现有系统的向后兼容性。 - * @param state 图的整体状态 - * @return 同步执行结果 - * @throws Exception 执行过程中可能出现的异常 - */ - @Override - default Map apply(OverAllState state) throws Exception { - return executeStreaming(state).blockFirst(); - } - - /** - * 判断是否为流式节点。 用于GraphEngine区分同步和流式节点的执行方式。 - * @return 总是返回true，表示这是一个流式节点 - */ - default boolean isStreaming() { - return true; - } - -} diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java index 4acc98e72d..76c2b1fab1 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java @@ -23,7 +23,6 @@ import com.alibaba.cloud.ai.graph.action.Command; import com.alibaba.cloud.ai.graph.action.InterruptableAction; import com.alibaba.cloud.ai.graph.action.InterruptionMetadata; -import com.alibaba.cloud.ai.graph.action.StreamingGraphNode; import com.alibaba.cloud.ai.graph.async.AsyncGenerator; import com.alibaba.cloud.ai.graph.exception.RunnableErrors; import com.alibaba.cloud.ai.graph.streaming.StreamingOutput; @@ -94,11 +93,6 @@ private Flux> executeNode(GraphRunnerContext context, } } - // 检查是否为流式节点 - if (action instanceof StreamingGraphNode) { - return executeStreamingNode((StreamingGraphNode) action, context, resultValue); - } - context.doListeners(NODE_BEFORE, null); CompletableFuture> future = action.apply(context.getOverallState(), @@ -410,55 +404,6 @@ private Flux> handleEmbeddedGenerator(GraphRunnerConte })); } - /** - * 执行流式节点，处理响应式数据流。 - * @param streamingNode 流式节点实例 - * @param context 图运行上下文 - * @param resultValue 结果值的原子引用 - * @return 流式图响应的Flux - */ - private Flux> executeStreamingNode(StreamingGraphNode streamingNode, - GraphRunnerContext context, AtomicReference resultValue) { - try { - context.doListeners(NODE_BEFORE, null); - - // 执行流式节点 - Flux> streamingFlux = streamingNode.executeStreaming(context.getOverallState()); - - return streamingFlux.map(output -> { - try { - // 为每个流元素创建NodeOutput - NodeOutput nodeOutput = context.buildNodeOutput(context.getCurrentNodeId()); - return GraphResponse.of(nodeOutput); - } - catch (Exception e) { - return GraphResponse.error(e); - } - }).concatWith(Flux.defer(() -> { - // 流结束后处理下一步 - context.doListeners(NODE_AFTER, null); - - try { - // 获取流的最后一个结果作为节点的最终输出 - // 注意：这里的逻辑假设流式节点会在最后一个元素中包含完整的状态更新 - Command nextCommand = context.nextNodeId(context.getCurrentNodeId(), context.getCurrentState()); - context.setNextNodeId(nextCommand.gotoNode()); - context.updateCurrentState(nextCommand.update()); - - return mainGraphExecutor.execute(context, resultValue); - } - catch (Exception e) { - return Flux.just(GraphResponse.error(e)); - } - })).onErrorResume(error -> { - context.doListeners(NODE_AFTER, null); - return Flux.just(GraphResponse.error(error)); - }); - } - catch (Exception e) { - return Flux.just(GraphResponse.error(e)); - } - } } From 2b437cebdbaf0085f46b1afbb2e3ce0fd3d5a9f7 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Tue, 23 Sep 2025 19:29:16 +0800 Subject: [PATCH 09/11] feat(graph): use mcpnode to solve streamhttpnode --- .../alibaba/cloud/ai/graph/node/McpNode.java | 590 ++++++++++++- .../graph/streaming/StreamHttpException.java | 85 -- .../ai/graph/streaming/StreamHttpNode.java | 506 ------------ .../graph/streaming/StreamHttpNodeParam.java | 311 ------- .../ai/graph/node/McpNodeHttpStreamTest.java | 423 ++++++++++ .../graph/streaming/StreamHttpNodeTest.java | 779 ------------------ 6 files changed, 992 insertions(+), 1702 deletions(-) delete mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java delete mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java delete mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java create mode 100644 spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java delete mode 100644 spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java index e5446dcf1c..d5c773da38 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java @@ -17,7 +17,11 @@ package com.alibaba.cloud.ai.graph.node; import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.action.NodeAction; +import com.alibaba.cloud.ai.graph.action.AsyncNodeAction; +import com.alibaba.cloud.ai.graph.async.AsyncGenerator; +import com.fasterxml.jackson.core.JsonProcessingException; +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; import io.modelcontextprotocol.client.McpClient; import io.modelcontextprotocol.client.McpSyncClient; import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport; @@ -27,38 +31,110 @@ import io.modelcontextprotocol.spec.McpSchema.TextContent; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.springframework.core.io.buffer.DataBuffer; +import org.springframework.http.HttpMethod; +import org.springframework.http.MediaType; import org.springframework.util.CollectionUtils; import org.springframework.util.StringUtils; - +import org.springframework.web.reactive.function.client.WebClient; +import org.springframework.web.reactive.function.client.WebClientResponseException; +import org.springframework.web.util.UriComponentsBuilder; +import reactor.core.publisher.Flux; +import reactor.util.retry.Retry; + +import java.net.URI; +import java.nio.charset.StandardCharsets; +import java.time.Duration; +import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.CompletableFuture; import java.util.regex.Matcher; import java.util.regex.Pattern; /** - * MCP Node: Node for calling MCP Server + * MCP Node: 多通道处理节点，支持 MCP 协议和 HTTP 流式处理 + * 作为图编排中的能力聚合和分发枢纽 */ -public class McpNode implements NodeAction { +public class McpNode implements AsyncNodeAction { private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\$\\{(.+?)\\}"); + private static final Pattern SSE_DATA_PATTERN = Pattern.compile("^data: (.*)$", Pattern.MULTILINE); + + private static final ObjectMapper objectMapper = new ObjectMapper(); + private static final Logger log = LoggerFactory.getLogger(McpNode.class); - private final String url; + // 处理模式枚举 + public enum McpProcessMode { + /** + * MCP 同步模式 - 原有功能 + */ + MCP_SYNC, + /** + * HTTP 流式模式 - 新增能力 + */ + HTTP_STREAM + } - private final String tool; + /** + * 流格式枚举 + */ + public enum StreamFormat { + /** + * Server-Sent Events格式 + */ + SSE, + /** + * JSON Lines格式 (每行一个JSON对象) + */ + JSON_LINES, + /** + * 纯文本流，按分隔符分割 + */ + TEXT_STREAM + } - private final Map headers; + /** + * 流处理模式枚举 + */ + public enum StreamMode { + /** + * 分发模式：流中的每个元素都触发下游节点执行 + */ + DISTRIBUTE, + /** + * 聚合模式：收集完整流后再执行下游节点 + */ + AGGREGATE + } + // 原有 MCP 配置 + private final String url; + private final String tool; + private final Map headers; private final Map params; - private final String outputKey; - private final List inputParamKeys; + // 处理模式配置 + private final McpProcessMode processMode; + + // HTTP 流式处理配置 + private final HttpMethod httpMethod; + private final Map queryParams; + private final StreamFormat streamFormat; + private final StreamMode streamMode; + private final Duration readTimeout; + private final boolean allowInternalAddress; + private final Duration bufferTimeout; + private final String delimiter; + private final WebClient webClient; + + // MCP 客户端（仅在 MCP_SYNC 模式使用） private HttpClientSseClientTransport transport; - private McpSyncClient client; private McpNode(Builder builder) { @@ -68,12 +144,42 @@ private McpNode(Builder builder) { this.params = builder.params; this.outputKey = builder.outputKey; this.inputParamKeys = builder.inputParamKeys; + + // 处理模式配置 + this.processMode = builder.processMode; + + // HTTP 流式处理配置 + this.httpMethod = builder.httpMethod; + this.queryParams = builder.queryParams; + this.streamFormat = builder.streamFormat; + this.streamMode = builder.streamMode; + this.readTimeout = builder.readTimeout; + this.allowInternalAddress = builder.allowInternalAddress; + this.bufferTimeout = builder.bufferTimeout; + this.delimiter = builder.delimiter; + this.webClient = builder.webClient; } @Override - public Map apply(OverAllState state) throws Exception { + public CompletableFuture> apply(OverAllState state) { + try { + // 根据处理模式路由到不同的处理逻辑 + return switch (processMode) { + case MCP_SYNC -> handleMcpSync(state); + case HTTP_STREAM -> handleHttpStream(state); + }; + } catch (Exception e) { + log.error("[McpNode] Execution failed: mode={}, error={}", processMode, e.getMessage(), e); + return CompletableFuture.completedFuture(createErrorOutput(e)); + } + } + + /** + * 处理 MCP 同步模式 - 保持原有逻辑 + */ + private CompletableFuture> handleMcpSync(OverAllState state) throws Exception { log.info( - "[McpNode] Start executing apply, original configuration: url={}, tool={}, headers={}, inputParamKeys={}", + "[McpNode] Start executing MCP sync, original configuration: url={}, tool={}, headers={}, inputParamKeys={}", url, tool, headers, inputParamKeys); // Build transport and client @@ -149,8 +255,349 @@ else if (first instanceof Map map && map.containsKey("text")) { updatedState.put(this.outputKey, content); } } - log.info("[McpNode] update state: {}", updatedState); - return updatedState; + log.info("[McpNode] MCP sync result: {}", updatedState); + return CompletableFuture.completedFuture(updatedState); + } + + /** + * 处理 HTTP 流式模式 + */ + private CompletableFuture> handleHttpStream(OverAllState state) { + try { + // 获取流式数据并转换为AsyncGenerator + Flux> streamFlux = executeStreaming(state); + + // 将Flux转换为AsyncGenerator，供图框架处理流式数据 + AsyncGenerator> generator = createAsyncGenerator(streamFlux); + + // 返回包含AsyncGenerator的结果Map + String outputKey = this.outputKey != null ? this.outputKey : "stream_output"; + return CompletableFuture.completedFuture(Map.of(outputKey, generator)); + } + catch (Exception e) { + log.error("[McpNode] HTTP stream initialization failed: url={}, method={}, error={}", url, + httpMethod, e.getMessage(), e); + // 返回包含错误信息的AsyncGenerator而不是直接返回Map + String outputKey = this.outputKey != null ? this.outputKey : "stream_output"; + Flux> errorFlux = Flux.just(createErrorOutput(e)); + AsyncGenerator> errorGenerator = createAsyncGenerator(errorFlux); + return CompletableFuture.completedFuture(Map.of(outputKey, errorGenerator)); + } + } + + /** + * 执行流式HTTP请求 + */ + private Flux> executeStreaming(OverAllState state) throws Exception { + String finalUrl = replaceVariables(this.url, state); + Map finalHeaders = replaceVariables(this.headers, state); + Map finalQueryParams = replaceVariables(this.queryParams, state); + + UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); + finalQueryParams.forEach(uriBuilder::queryParam); + URI finalUri = uriBuilder.build().toUri(); + + validateUrl(finalUri.toString()); + + WebClient.RequestBodySpec requestSpec = webClient + .method(httpMethod) + .uri(finalUri) + .headers(headers -> headers.setAll(finalHeaders)); + + // 处理请求体 + if (params != null && !params.isEmpty()) { + Map finalParams = replaceVariablesObj(params, state); + requestSpec.headers(h -> h.setContentType(MediaType.APPLICATION_JSON)); + requestSpec.bodyValue(finalParams); + } + + // 直接返回处理后的结果，将HTTP错误转换为错误数据项 + return requestSpec.exchangeToFlux(response -> { + if (!response.statusCode().is2xxSuccessful()) { + // 处理HTTP错误 + return response.bodyToMono(String.class) + .defaultIfEmpty("HTTP Error") + .map(errorBody -> { + WebClientResponseException exception = new WebClientResponseException( + response.statusCode().value(), "HTTP " + response.statusCode() + ": " + errorBody, + null, null, null); + return createErrorOutput(exception); + }) + .flux(); + } + + // 处理成功响应 + Flux dataBufferFlux = response.bodyToFlux(DataBuffer.class); + return processStreamResponse(dataBufferFlux, state); + }) + .retryWhen(Retry.backoff(3, Duration.ofMillis(1000))) // 默认重试配置 + .timeout(readTimeout) + .onErrorResume(throwable -> { + log.error("[McpNode] HTTP stream execution failed: url={}, method={}, error={}", finalUrl, + httpMethod, throwable.getMessage(), throwable); + return Flux.just(createErrorOutput(throwable)); + }); + } + + /** + * 将Flux转换为AsyncGenerator + */ + private AsyncGenerator> createAsyncGenerator(Flux> flux) { + return new AsyncGenerator>() { + private final java.util.concurrent.BlockingQueue>> queue = + new java.util.concurrent.LinkedBlockingQueue<>(); + + { + // 异步处理Flux数据 + flux.subscribe( + data -> queue.offer(AsyncGenerator.Data.of(CompletableFuture.completedFuture(data))), + error -> queue.offer(AsyncGenerator.Data.error(error)), + () -> queue.offer(AsyncGenerator.Data.done()) + ); + } + + @Override + public AsyncGenerator.Data> next() { + try { + return queue.take(); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + return AsyncGenerator.Data.error(e); + } + } + }; + } + + /** + * 处理流式响应数据 + */ + private Flux> processStreamResponse(Flux responseFlux, OverAllState state) { + return responseFlux.map(dataBuffer -> { + byte[] bytes = new byte[dataBuffer.readableByteCount()]; + dataBuffer.read(bytes); + return new String(bytes, StandardCharsets.UTF_8); + }) + .buffer(bufferTimeout) + .map(chunks -> String.join("", chunks)) + .flatMap(this::parseStreamChunk) + .filter(data -> { + if (data instanceof String) { + return !((String) data).isEmpty(); + } + return data != null; + }) + .map(this::wrapOutput) + .transform(flux -> { + if (streamMode == StreamMode.AGGREGATE) { + return flux.collectList().map(this::aggregateResults).flux(); + } + return flux; + }) + .onErrorResume(error -> { + log.error("[McpNode] Error processing stream response", error); + return Flux.just(createErrorOutput(error)); + }); + } + + /** + * 解析流数据块 + */ + private Flux parseStreamChunk(String chunk) { + return switch (streamFormat) { + case SSE -> parseSSEChunk(chunk).cast(Object.class); + case JSON_LINES -> parseJsonLinesChunk(chunk); + case TEXT_STREAM -> parseTextStreamChunk(chunk).cast(Object.class); + }; + } + + /** + * 解析SSE格式数据 + */ + private Flux parseSSEChunk(String chunk) { + List results = new ArrayList<>(); + Matcher matcher = SSE_DATA_PATTERN.matcher(chunk); + + while (matcher.find()) { + String data = matcher.group(1).trim(); + if (!data.isEmpty() && !"[DONE]".equals(data)) { + results.add(data); + } + } + + return Flux.fromIterable(results); + } + + /** + * 解析JSON Lines格式数据 + */ + private Flux parseJsonLinesChunk(String chunk) { + String[] lines = chunk.split("\n"); + List results = new ArrayList<>(); + + for (String line : lines) { + line = line.trim(); + if (!line.isEmpty()) { + try { + objectMapper.readTree(line); + results.add(line); + } + catch (JsonProcessingException e) { + log.warn("[McpNode] Invalid JSON line: {}, error: {}", line, e.getMessage()); + Map errorMap = new HashMap<>(); + errorMap.put("_parsing_error", e.getMessage()); + errorMap.put("_raw_data", line); + results.add(errorMap); + } + } + } + + return Flux.fromIterable(results); + } + + /** + * 解析文本流数据 + */ + private Flux parseTextStreamChunk(String chunk) { + String[] parts = chunk.split(Pattern.quote(delimiter)); + List results = new ArrayList<>(); + + for (String part : parts) { + part = part.trim(); + if (!part.isEmpty()) { + results.add(part); + } + } + + return Flux.fromIterable(results); + } + + /** + * 包装输出数据 + */ + private Map wrapOutput(Object data) { + Map result = new HashMap<>(); + + if (data instanceof Map) { + result.put("data", data); + } + else if (data instanceof String) { + String stringData = (String) data; + try { + if (stringData.startsWith("{") || stringData.startsWith("[")) { + JsonNode jsonNode = objectMapper.readTree(stringData); + Object parsedData = objectMapper.convertValue(jsonNode, Object.class); + result.put("data", parsedData); + } + else { + result.put("data", stringData); + } + } + catch (JsonProcessingException e) { + result.put("data", stringData); + } + } + else { + result.put("data", data); + } + + result.put("timestamp", System.currentTimeMillis()); + result.put("streaming", true); + + if (StringUtils.hasLength(outputKey)) { + Map keyedResult = new HashMap<>(); + keyedResult.put(outputKey, result); + return keyedResult; + } + + return result; + } + + /** + * 聚合模式下的结果汇总 + */ + private Map aggregateResults(List> results) { + Map aggregated = new HashMap<>(); + List dataList = new ArrayList<>(); + + for (Map result : results) { + if (outputKey != null && result.containsKey(outputKey)) { + Map keyedData = (Map) result.get(outputKey); + dataList.add(keyedData.get("data")); + } + else { + dataList.add(result.get("data")); + } + } + + aggregated.put("data", dataList); + aggregated.put("count", results.size()); + aggregated.put("streaming", false); + aggregated.put("aggregated", true); + aggregated.put("timestamp", System.currentTimeMillis()); + + if (StringUtils.hasLength(outputKey)) { + Map keyedResult = new HashMap<>(); + keyedResult.put(outputKey, aggregated); + return keyedResult; + } + + return aggregated; + } + + /** + * 创建错误输出 + */ + private Map createErrorOutput(Throwable error) { + Map errorResult = new HashMap<>(); + errorResult.put("error", error.getMessage()); + errorResult.put("timestamp", System.currentTimeMillis()); + errorResult.put("streaming", false); + + if (StringUtils.hasLength(outputKey)) { + Map keyedResult = new HashMap<>(); + keyedResult.put(outputKey, errorResult); + return keyedResult; + } + + return errorResult; + } + + /** + * URL安全验证 + */ + private void validateUrl(String url) { + try { + URI uri = URI.create(url); + String host = uri.getHost(); + + if (host == null) { + throw new IllegalArgumentException("Invalid URL: missing host"); + } + + // 检查内网地址访问权限 + if (isInternalAddress(host) && !allowInternalAddress) { + throw new SecurityException( + "Internal network access not allowed: " + host + ". Set allowInternalAddress=true to enable."); + } + + // 验证协议 + String scheme = uri.getScheme(); + if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) { + throw new IllegalArgumentException("Only HTTP/HTTPS protocols are supported: " + scheme); + } + + } + catch (IllegalArgumentException | SecurityException e) { + throw new McpNodeException("URL validation failed: " + e.getMessage(), e); + } + } + + /** + * 检查是否为内网地址 + */ + private boolean isInternalAddress(String host) { + return host.startsWith("127.") || host.startsWith("10.") || host.startsWith("192.168.") + || host.matches("172\\.(1[6-9]|2[0-9]|3[0-1])\\..*") || "localhost".equalsIgnoreCase(host); } private String replaceVariables(String template, OverAllState state) { @@ -161,13 +608,20 @@ private String replaceVariables(String template, OverAllState state) { while (matcher.find()) { String key = matcher.group(1); Object value = state.value(key).orElse(""); - log.info("[McpNode] replace param: {} -> {}", key, value); - matcher.appendReplacement(result, value.toString()); + log.debug("[McpNode] replace param: {} -> {}", key, value); + matcher.appendReplacement(result, Matcher.quoteReplacement(value.toString())); } matcher.appendTail(result); return result.toString(); } + private Map replaceVariables(Map map, OverAllState state) { + if (map == null) return new HashMap<>(); + Map result = new HashMap<>(); + map.forEach((k, v) -> result.put(k, replaceVariables(v, state))); + return result; + } + private Map replaceVariablesObj(Map map, OverAllState state) { if (map == null) return null; @@ -189,18 +643,28 @@ public static Builder builder() { public static class Builder { + // 原有 MCP 配置 private String url; - private String tool; - private Map headers = new HashMap<>(); - private Map params = new HashMap<>(); - private String outputKey; - private List inputParamKeys; + // 处理模式配置 + private McpProcessMode processMode = McpProcessMode.MCP_SYNC; // 默认保持原有行为 + + // HTTP 流式处理配置 + private HttpMethod httpMethod = HttpMethod.GET; + private Map queryParams = new HashMap<>(); + private StreamFormat streamFormat = StreamFormat.SSE; + private StreamMode streamMode = StreamMode.DISTRIBUTE; + private Duration readTimeout = Duration.ofMinutes(5); + private boolean allowInternalAddress = false; + private Duration bufferTimeout = Duration.ofMillis(100); + private String delimiter = "\n"; + private WebClient webClient = WebClient.create(); + public Builder url(String url) { this.url = url; return this; @@ -231,7 +695,91 @@ public Builder inputParamKeys(List inputParamKeys) { return this; } + // 处理模式配置 + public Builder processMode(McpProcessMode processMode) { + this.processMode = processMode; + return this; + } + + // HTTP 流式处理配置方法 + public Builder httpMethod(HttpMethod httpMethod) { + this.httpMethod = httpMethod; + return this; + } + + public Builder queryParam(String name, String value) { + this.queryParams.put(name, value); + return this; + } + + public Builder queryParams(Map queryParams) { + this.queryParams.putAll(queryParams); + return this; + } + + public Builder streamFormat(StreamFormat streamFormat) { + this.streamFormat = streamFormat; + return this; + } + + public Builder streamMode(StreamMode streamMode) { + this.streamMode = streamMode; + return this; + } + + public Builder readTimeout(Duration readTimeout) { + this.readTimeout = readTimeout; + return this; + } + + public Builder allowInternalAddress(boolean allowInternalAddress) { + this.allowInternalAddress = allowInternalAddress; + return this; + } + + public Builder bufferTimeout(Duration bufferTimeout) { + this.bufferTimeout = bufferTimeout; + return this; + } + + public Builder delimiter(String delimiter) { + this.delimiter = delimiter; + return this; + } + + public Builder webClient(WebClient webClient) { + this.webClient = webClient; + return this; + } + + /** + * 便捷方法：启用HTTP流式模式 + */ + public Builder enableHttpStream() { + this.processMode = McpProcessMode.HTTP_STREAM; + return this; + } + + /** + * 便捷方法：启用HTTP流式模式并设置基本参数 + */ + public Builder enableHttpStream(HttpMethod method, StreamFormat format) { + this.processMode = McpProcessMode.HTTP_STREAM; + this.httpMethod = method; + this.streamFormat = format; + return this; + } + public McpNode build() { + // 验证配置 + if (url == null || url.trim().isEmpty()) { + throw new IllegalArgumentException("URL cannot be null or empty"); + } + + if (processMode == McpProcessMode.MCP_SYNC && (tool == null || tool.trim().isEmpty())) { + throw new IllegalArgumentException("Tool name is required for MCP_SYNC mode"); + } + return new McpNode(this); } diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java deleted file mode 100644 index 399d9afe2a..0000000000 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpException.java +++ /dev/null @@ -1,85 +0,0 @@ -/* - * Copyright 2024-2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.alibaba.cloud.ai.graph.streaming; - -/** - * StreamHttpNode专用异常类 提供更详细的流式HTTP处理异常信息 - */ -public class StreamHttpException extends RuntimeException { - - private final String nodeId; - - private final int httpStatus; - - private final String url; - - public StreamHttpException(String nodeId, String url, String message) { - this(nodeId, url, -1, message, null); - } - - public StreamHttpException(String nodeId, String url, String message, Throwable cause) { - this(nodeId, url, -1, message, cause); - } - - public StreamHttpException(String nodeId, String url, int httpStatus, String message, Throwable cause) { - super(String.format("StreamHttpNode[%s] failed: %s (URL: %s, Status: %d)", nodeId, message, url, httpStatus), - cause); - this.nodeId = nodeId; - this.httpStatus = httpStatus; - this.url = url; - } - - public String getNodeId() { - return nodeId; - } - - public int getHttpStatus() { - return httpStatus; - } - - public String getUrl() { - return url; - } - - /** - * 创建网络异常 - */ - public static StreamHttpException networkError(String nodeId, String url, Throwable cause) { - return new StreamHttpException(nodeId, url, "Network connection failed", cause); - } - - /** - * 创建HTTP状态异常 - */ - public static StreamHttpException httpError(String nodeId, String url, int status, String message) { - return new StreamHttpException(nodeId, url, status, "HTTP error: " + message, null); - } - - /** - * 创建数据解析异常 - */ - public static StreamHttpException parseError(String nodeId, String url, String message, Throwable cause) { - return new StreamHttpException(nodeId, url, "Data parsing failed: " + message, cause); - } - - /** - * 创建超时异常 - */ - public static StreamHttpException timeoutError(String nodeId, String url, String message) { - return new StreamHttpException(nodeId, url, "Request timeout: " + message, null); - } - -} diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java deleted file mode 100644 index 6141144b59..0000000000 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNode.java +++ /dev/null @@ -1,506 +0,0 @@ -/* - * Copyright 2024-2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.alibaba.cloud.ai.graph.streaming; - -import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.action.AsyncNodeAction; -import com.alibaba.cloud.ai.graph.async.AsyncGenerator; -import com.alibaba.cloud.ai.graph.exception.GraphRunnerException; -import com.alibaba.cloud.ai.graph.exception.RunnableErrors; -import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamMode; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.springframework.core.io.buffer.DataBuffer; -import org.springframework.http.MediaType; -import org.springframework.util.StringUtils; -import org.springframework.web.reactive.function.client.WebClient; -import org.springframework.web.reactive.function.client.WebClientResponseException; -import org.springframework.web.util.UriComponentsBuilder; -import reactor.core.publisher.Flux; -import reactor.util.retry.Retry; - -import java.net.URI; -import java.nio.charset.StandardCharsets; -import java.time.Duration; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.regex.Matcher; -import java.util.regex.Pattern; - -import static com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamFormat.*; - -public class StreamHttpNode implements AsyncNodeAction { - - private static final Logger logger = LoggerFactory.getLogger(StreamHttpNode.class); - - private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\$\\{(.+?)\\}"); - - private static final Pattern SSE_DATA_PATTERN = Pattern.compile("^data: (.*)$", Pattern.MULTILINE); - - private static final ObjectMapper objectMapper = new ObjectMapper(); - - private final StreamHttpNodeParam param; - - public StreamHttpNode(StreamHttpNodeParam param) { - this.param = param; - } - - @Override - public CompletableFuture> apply(OverAllState state) { - try { - // 获取流式数据并转换为AsyncGenerator - Flux> streamFlux = executeStreaming(state); - - // 将Flux转换为AsyncGenerator，供图框架处理流式数据 - AsyncGenerator> generator = createAsyncGenerator(streamFlux); - - // 返回包含AsyncGenerator的结果Map - String outputKey = param.getOutputKey() != null ? param.getOutputKey() : "stream_output"; - return CompletableFuture.completedFuture(Map.of(outputKey, generator)); - } - catch (Exception e) { - logger.error("StreamHttpNode initialization failed: url={}, method={}, error={}", param.getUrl(), - param.getMethod(), e.getMessage(), e); - // 返回包含错误信息的AsyncGenerator而不是直接返回Map - String outputKey = param.getOutputKey() != null ? param.getOutputKey() : "stream_output"; - Flux> errorFlux = Flux.just(createErrorOutput(e)); - AsyncGenerator> errorGenerator = createAsyncGenerator(errorFlux); - return CompletableFuture.completedFuture(Map.of(outputKey, errorGenerator)); - } - } - - /** - * 执行流式HTTP请求 - 保持原有的流式逻辑 - * Package-private for testing - */ - Flux> executeStreaming(OverAllState state) throws Exception { - String finalUrl = replaceVariables(param.getUrl(), state); - Map finalHeaders = replaceVariables(param.getHeaders(), state); - Map finalQueryParams = replaceVariables(param.getQueryParams(), state); - - UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); - finalQueryParams.forEach(uriBuilder::queryParam); - URI finalUri = uriBuilder.build().toUri(); - - validateUrl(finalUri.toString()); // 添加URL安全验证，在URI构建之后 - - WebClient.RequestBodySpec requestSpec = param.getWebClient() - .method(param.getMethod()) - .uri(finalUri) - .headers(headers -> headers.setAll(finalHeaders)); - - applyAuth(requestSpec); - initBody(requestSpec, state); - - // 直接返回处理后的结果，将HTTP错误转换为错误数据项 - return requestSpec.exchangeToFlux(response -> { - if (!response.statusCode().is2xxSuccessful()) { - // 处理HTTP错误：将错误转换为包含错误信息的Map，作为数据项发射出去 - return response.bodyToMono(String.class) - .defaultIfEmpty("HTTP Error") // 如果响应体为空，使用默认错误信息 - .map(errorBody -> { - // 创建错误信息Map - WebClientResponseException exception = new WebClientResponseException( - response.statusCode().value(), "HTTP " + response.statusCode() + ": " + errorBody, - null, null, null); - return createErrorOutput(exception); - }) - .flux(); // 转换为Flux - } - - // 处理成功响应 - Flux dataBufferFlux = response.bodyToFlux(DataBuffer.class); - return processStreamResponse(dataBufferFlux, state); - }) - .retryWhen(Retry.backoff(param.getRetryConfig().getMaxRetries(), - Duration.ofMillis(param.getRetryConfig().getMaxRetryInterval()))) - .timeout(param.getReadTimeout()) - // 处理网络超时、连接错误等其他异常 - .onErrorResume(throwable -> { - logger.error("StreamHttpNode execution failed: url={}, method={}, error={}", finalUrl, - param.getMethod(), throwable.getMessage(), throwable); - return Flux.just(createErrorOutput(throwable)); - }); - } - - /** - * 将Flux转换为AsyncGenerator，供图框架处理流式数据 - */ - private AsyncGenerator> createAsyncGenerator(Flux> flux) { - return new AsyncGenerator>() { - private boolean completed = false; - private final java.util.concurrent.BlockingQueue>> queue = - new java.util.concurrent.LinkedBlockingQueue<>(); - - { - // 异步处理Flux数据 - flux.subscribe( - data -> queue.offer(AsyncGenerator.Data.of(CompletableFuture.completedFuture(data))), - error -> queue.offer(AsyncGenerator.Data.error(error)), - () -> { - completed = true; - queue.offer(AsyncGenerator.Data.done()); - } - ); - } - - @Override - public AsyncGenerator.Data> next() { - try { - return queue.take(); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - return AsyncGenerator.Data.error(e); - } - } - }; - } - - /** - * 处理流式响应数据 - */ - private Flux> processStreamResponse(Flux responseFlux, OverAllState state) { - return responseFlux.map(dataBuffer -> { - byte[] bytes = new byte[dataBuffer.readableByteCount()]; - dataBuffer.read(bytes); - return new String(bytes, StandardCharsets.UTF_8); - }) - .buffer(param.getBufferTimeout()) // 使用配置的缓冲超时时间避免内存累积 - .map(chunks -> String.join("", chunks)) - .flatMap(this::parseStreamChunk) - .filter(data -> { - if (data instanceof String) { - return !((String) data).isEmpty(); - } - return data != null; // 对于Map对象，只要不为null就保留 - }) - .map(this::wrapOutput) - .transform(flux -> { - if (param.getStreamMode() == StreamMode.AGGREGATE) { - return flux.collectList().map(this::aggregateResults).flux(); - } - return flux; - }) - .onErrorResume(error -> { - // 处理数据处理层面的错误 - logger.error("Error processing stream response", error); - return Flux.just(createErrorOutput(error)); - }); - } - - /** - * 解析流数据块 - */ - private Flux parseStreamChunk(String chunk) { - return switch (param.getStreamFormat()) { - case SSE -> parseSSEChunk(chunk).cast(Object.class); - case JSON_LINES -> parseJsonLinesChunk(chunk); - case TEXT_STREAM -> parseTextStreamChunk(chunk).cast(Object.class); - }; - } - - /** - * 解析SSE格式数据 - */ - private Flux parseSSEChunk(String chunk) { - List results = new ArrayList<>(); - Matcher matcher = SSE_DATA_PATTERN.matcher(chunk); - - while (matcher.find()) { - String data = matcher.group(1).trim(); - if (!data.isEmpty() && !"[DONE]".equals(data)) { - results.add(data); - } - } - - return Flux.fromIterable(results); - } - - /** - * 解析JSON Lines格式数据 - */ - private Flux parseJsonLinesChunk(String chunk) { - String[] lines = chunk.split("\n"); - List results = new ArrayList<>(); - - for (String line : lines) { - line = line.trim(); - if (!line.isEmpty()) { - try { - objectMapper.readTree(line); - results.add(line); - } - catch (JsonProcessingException e) { - logger.warn("Invalid JSON line: {}, error: {}", line, e.getMessage()); - // 返回包含错误信息的Map对象，用于直接处理 - Map errorMap = new HashMap<>(); - errorMap.put("_parsing_error", e.getMessage()); - errorMap.put("_raw_data", line); - results.add(errorMap); - } - } - } - - return Flux.fromIterable(results); - } - - /** - * 解析文本流数据 - */ - private Flux parseTextStreamChunk(String chunk) { - String[] parts = chunk.split(Pattern.quote(param.getDelimiter())); - List results = new ArrayList<>(); - - for (String part : parts) { - part = part.trim(); - if (!part.isEmpty()) { - results.add(part); - } - } - - return Flux.fromIterable(results); - } - - /** - * 包装输出数据 - */ - private Map wrapOutput(Object data) { - Map result = new HashMap<>(); - - if (data instanceof Map) { - // 如果已经是Map对象（如错误处理的结果），直接使用 - result.put("data", data); - } - else if (data instanceof String) { - String stringData = (String) data; - try { - if (stringData.startsWith("{") || stringData.startsWith("[")) { - JsonNode jsonNode = objectMapper.readTree(stringData); - Object parsedData = objectMapper.convertValue(jsonNode, Object.class); - result.put("data", parsedData); - } - else { - result.put("data", stringData); - } - } - catch (JsonProcessingException e) { - result.put("data", stringData); - } - } - else { - // 对于其他类型的数据，直接使用 - result.put("data", data); - } - - result.put("timestamp", System.currentTimeMillis()); - result.put("streaming", true); - - if (StringUtils.hasLength(param.getOutputKey())) { - Map keyedResult = new HashMap<>(); - keyedResult.put(param.getOutputKey(), result); - return keyedResult; - } - - return result; - } - - /** - * 聚合模式下的结果汇总 - */ - private Map aggregateResults(List> results) { - Map aggregated = new HashMap<>(); - List dataList = new ArrayList<>(); - - for (Map result : results) { - if (param.getOutputKey() != null && result.containsKey(param.getOutputKey())) { - Map keyedData = (Map) result.get(param.getOutputKey()); - dataList.add(keyedData.get("data")); - } - else { - dataList.add(result.get("data")); - } - } - - aggregated.put("data", dataList); - aggregated.put("count", results.size()); - aggregated.put("streaming", false); - aggregated.put("aggregated", true); - aggregated.put("timestamp", System.currentTimeMillis()); - - if (StringUtils.hasLength(param.getOutputKey())) { - Map keyedResult = new HashMap<>(); - keyedResult.put(param.getOutputKey(), aggregated); - return keyedResult; - } - - return aggregated; - } - - /** - * 创建错误输出 - */ - private Map createErrorOutput(Throwable error) { - Map errorResult = new HashMap<>(); - errorResult.put("error", error.getMessage()); - errorResult.put("timestamp", System.currentTimeMillis()); - errorResult.put("streaming", false); - - if (StringUtils.hasLength(param.getOutputKey())) { - Map keyedResult = new HashMap<>(); - keyedResult.put(param.getOutputKey(), errorResult); - return keyedResult; - } - - return errorResult; - } - - /** - * 替换变量占位符 - */ - private String replaceVariables(String template, OverAllState state) { - if (template == null) - return null; - - Matcher matcher = VARIABLE_PATTERN.matcher(template); - StringBuilder result = new StringBuilder(); - - while (matcher.find()) { - String key = matcher.group(1); - Object value = state.value(key).orElse(""); - String replacement = value != null ? value.toString() : ""; - // 不进行编码，让UriComponentsBuilder处理 - matcher.appendReplacement(result, Matcher.quoteReplacement(replacement)); - } - - matcher.appendTail(result); - return result.toString(); - } - - /** - * 替换Map中的变量占位符 - */ - private Map replaceVariables(Map map, OverAllState state) { - Map result = new HashMap<>(); - map.forEach((k, v) -> result.put(k, replaceVariables(v, state))); - return result; - } - - /** - * 应用认证配置 - */ - private void applyAuth(WebClient.RequestBodySpec requestSpec) { - if (param.getAuthConfig() != null) { - if (param.getAuthConfig().isBasic()) { - requestSpec.headers(headers -> headers.setBasicAuth(param.getAuthConfig().getUsername(), - param.getAuthConfig().getPassword())); - } - else if (param.getAuthConfig().isBearer()) { - requestSpec.headers(headers -> headers.setBearerAuth(param.getAuthConfig().getToken())); - } - } - } - - /** - * 初始化请求体 - */ - private void initBody(WebClient.RequestBodySpec requestSpec, OverAllState state) throws GraphRunnerException { - if (param.getBody() == null || !param.getBody().hasContent()) { - return; - } - - switch (param.getBody().getType()) { - case NONE: - break; - case RAW_TEXT: - if (param.getBody().getData().size() != 1) { - throw RunnableErrors.nodeInterrupt.exception("RAW_TEXT body must contain exactly one item"); - } - String rawText = replaceVariables(param.getBody().getData().get(0).getValue(), state); - requestSpec.headers(h -> h.setContentType(MediaType.TEXT_PLAIN)); - requestSpec.bodyValue(rawText); - break; - case JSON: - if (param.getBody().getData().size() != 1) { - throw RunnableErrors.nodeInterrupt.exception("JSON body must contain exactly one item"); - } - String jsonTemplate = replaceVariables(param.getBody().getData().get(0).getValue(), state); - try { - Object jsonObject = objectMapper.readValue(jsonTemplate, Object.class); - requestSpec.headers(h -> h.setContentType(MediaType.APPLICATION_JSON)); - requestSpec.bodyValue(jsonObject); - } - catch (JsonProcessingException e) { - throw RunnableErrors.nodeInterrupt.exception("Failed to parse JSON body: " + e.getMessage()); - } - break; - default: - logger.warn("Body type {} not fully supported in streaming mode", param.getBody().getType()); - } - } - - /** - * URL安全验证 - */ - private void validateUrl(String url) { - try { - URI uri = URI.create(url); - String host = uri.getHost(); - - if (host == null) { - throw new IllegalArgumentException("Invalid URL: missing host"); - } - - // 检查内网地址访问权限 - if (isInternalAddress(host) && !param.isAllowInternalAddress()) { - throw new SecurityException( - "Internal network access not allowed: " + host + ". Set allowInternalAddress=true to enable."); - } - - // 验证协议 - String scheme = uri.getScheme(); - if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) { - throw new IllegalArgumentException("Only HTTP/HTTPS protocols are supported: " + scheme); - } - - } - catch (IllegalArgumentException | SecurityException e) { - throw new StreamHttpException("stream-http", url, "URL validation failed: " + e.getMessage(), e); - } - } - - /** - * 检查是否为内网地址 - */ - private boolean isInternalAddress(String host) { - // 简单的内网地址检查 - return host.startsWith("127.") || host.startsWith("10.") || host.startsWith("192.168.") - || host.matches("172\\.(1[6-9]|2[0-9]|3[0-1])\\..*") || "localhost".equalsIgnoreCase(host); - } - - /** - * 构建器模式的工厂方法 - */ - public static StreamHttpNode create(StreamHttpNodeParam param) { - return new StreamHttpNode(param); - } - -} diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java deleted file mode 100644 index 55d8d20c11..0000000000 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeParam.java +++ /dev/null @@ -1,311 +0,0 @@ -/* - * Copyright 2024-2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.alibaba.cloud.ai.graph.streaming; - -import com.alibaba.cloud.ai.graph.node.HttpNode.AuthConfig; -import com.alibaba.cloud.ai.graph.node.HttpNode.HttpRequestNodeBody; -import com.alibaba.cloud.ai.graph.node.HttpNode.RetryConfig; -import org.springframework.http.HttpMethod; -import org.springframework.web.reactive.function.client.WebClient; - -import java.time.Duration; -import java.util.HashMap; -import java.util.Map; - -public class StreamHttpNodeParam { - - private WebClient webClient = WebClient.create(); - - private HttpMethod method = HttpMethod.GET; - - private String url; - - private Map headers = new HashMap<>(); - - private Map queryParams = new HashMap<>(); - - private HttpRequestNodeBody body = new HttpRequestNodeBody(); - - private AuthConfig authConfig; - - private RetryConfig retryConfig = new RetryConfig(3, 1000, true); - - private String outputKey; - - // 流式处理特有的配置 - private StreamFormat streamFormat = StreamFormat.SSE; - - // 性能和安全配置 - private long maxResponseSize = 50 * 1024 * 1024; // 50MB限制 - - private int maxRedirects = 5; // 重定向次数限制 - - private boolean allowInternalAddress = false; // 是否允许访问内网地址 - - private Duration bufferTimeout = Duration.ofMillis(100); // 缓冲超时时间 - - private StreamMode streamMode = StreamMode.DISTRIBUTE; - - private Duration readTimeout = Duration.ofMinutes(5); - - private int bufferSize = 8192; - - private String delimiter = "\n"; - - /** - * 流格式枚举 - */ - public enum StreamFormat { - - /** - * Server-Sent Events格式 - */ - SSE, - /** - * JSON Lines格式 (每行一个JSON对象) - */ - JSON_LINES, - /** - * 纯文本流，按分隔符分割 - */ - TEXT_STREAM - - } - - /** - * 流处理模式枚举 - */ - public enum StreamMode { - - /** - * 分发模式：流中的每个元素都触发下游节点执行 - */ - DISTRIBUTE, - /** - * 聚合模式：收集完整流后再执行下游节点 - */ - AGGREGATE - - } - - // Builder pattern - public static Builder builder() { - return new Builder(); - } - - public static class Builder { - - private final StreamHttpNodeParam param = new StreamHttpNodeParam(); - - public Builder webClient(WebClient webClient) { - param.webClient = webClient; - return this; - } - - public Builder method(HttpMethod method) { - param.method = method; - return this; - } - - public Builder url(String url) { - param.url = url; - return this; - } - - public Builder header(String name, String value) { - param.headers.put(name, value); - return this; - } - - public Builder headers(Map headers) { - param.headers.putAll(headers); - return this; - } - - public Builder queryParam(String name, String value) { - param.queryParams.put(name, value); - return this; - } - - public Builder queryParams(Map queryParams) { - param.queryParams.putAll(queryParams); - return this; - } - - public Builder body(HttpRequestNodeBody body) { - param.body = body; - return this; - } - - public Builder auth(AuthConfig authConfig) { - param.authConfig = authConfig; - return this; - } - - public Builder retryConfig(RetryConfig retryConfig) { - param.retryConfig = retryConfig; - return this; - } - - public Builder outputKey(String outputKey) { - param.outputKey = outputKey; - return this; - } - - public Builder streamFormat(StreamFormat streamFormat) { - param.streamFormat = streamFormat; - return this; - } - - public Builder streamMode(StreamMode streamMode) { - param.streamMode = streamMode; - return this; - } - - public Builder readTimeout(Duration readTimeout) { - param.readTimeout = readTimeout; - return this; - } - - public Builder bufferSize(int bufferSize) { - param.bufferSize = bufferSize; - return this; - } - - public Builder delimiter(String delimiter) { - param.delimiter = delimiter; - return this; - } - - public Builder allowInternalAddress(boolean allowInternalAddress) { - param.allowInternalAddress = allowInternalAddress; - return this; - } - - public Builder bufferTimeout(Duration bufferTimeout) { - param.bufferTimeout = bufferTimeout; - return this; - } - - public Builder maxResponseSize(long maxResponseSize) { - param.maxResponseSize = maxResponseSize; - return this; - } - - public Builder maxRedirects(int maxRedirects) { - param.maxRedirects = maxRedirects; - return this; - } - - public StreamHttpNodeParam build() { - if (param.url == null || param.url.trim().isEmpty()) { - throw new IllegalArgumentException("URL cannot be null or empty"); - } - return param; - } - - } - - // Getters - public WebClient getWebClient() { - return webClient; - } - - public HttpMethod getMethod() { - return method; - } - - public String getUrl() { - return url; - } - - public Map getHeaders() { - return headers; - } - - public Map getQueryParams() { - return queryParams; - } - - public HttpRequestNodeBody getBody() { - return body; - } - - public AuthConfig getAuthConfig() { - return authConfig; - } - - public RetryConfig getRetryConfig() { - return retryConfig; - } - - public String getOutputKey() { - return outputKey; - } - - public StreamFormat getStreamFormat() { - return streamFormat; - } - - public StreamMode getStreamMode() { - return streamMode; - } - - public Duration getReadTimeout() { - return readTimeout; - } - - public int getBufferSize() { - return bufferSize; - } - - public String getDelimiter() { - return delimiter; - } - - public long getMaxResponseSize() { - return maxResponseSize; - } - - public void setMaxResponseSize(long maxResponseSize) { - this.maxResponseSize = maxResponseSize; - } - - public int getMaxRedirects() { - return maxRedirects; - } - - public void setMaxRedirects(int maxRedirects) { - this.maxRedirects = maxRedirects; - } - - public boolean isAllowInternalAddress() { - return allowInternalAddress; - } - - public void setAllowInternalAddress(boolean allowInternalAddress) { - this.allowInternalAddress = allowInternalAddress; - } - - public Duration getBufferTimeout() { - return bufferTimeout; - } - - public void setBufferTimeout(Duration bufferTimeout) { - this.bufferTimeout = bufferTimeout; - } - -} diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java new file mode 100644 index 0000000000..ac7314ea34 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java @@ -0,0 +1,423 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.alibaba.cloud.ai.graph.node; + +import com.alibaba.cloud.ai.graph.OverAllState; +import com.alibaba.cloud.ai.graph.OverAllStateBuilder; +import com.alibaba.cloud.ai.graph.async.AsyncGenerator; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.api.Timeout; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpMethod; +import org.springframework.http.MediaType; +import org.springframework.web.reactive.function.client.WebClient; +import reactor.core.publisher.Flux; +import reactor.test.StepVerifier; + +import java.io.IOException; +import java.time.Duration; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.TimeUnit; + +import static org.assertj.core.api.Assertions.assertThat; + +/** + * McpNode HTTP流式功能测试 + */ +class McpNodeHttpStreamTest { + + private MockWebServer mockWebServer; + + private OverAllState testState; + + @BeforeEach + void setUp() throws IOException { + mockWebServer = new MockWebServer(); + mockWebServer.start(); + + testState = OverAllStateBuilder.builder() + .putData("test_key", "test_value") + .putData("user_input", "Hello World") + .build(); + } + + @AfterEach + void tearDown() throws IOException { + if (mockWebServer != null) { + mockWebServer.shutdown(); + } + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_SSE() throws Exception { + // 模拟SSE响应 + String sseResponse = """ + data: {"type": "message", "content": "Hello"} + + data: {"type": "message", "content": "World"} + + data: {"type": "done"} + + """; + + mockWebServer.enqueue(new MockResponse().setBody(sseResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) + .setResponseCode(200)); + + McpNode mcpNode = McpNode.builder() + .url(mockWebServer.url("/sse").toString()) + .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.SSE) + .streamMode(McpNode.StreamMode.DISTRIBUTE) + .outputKey("sse_output") + .allowInternalAddress(true) + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("sse_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result) + .assertNext(output -> { + assertThat(output).containsKey("sse_output"); + Map sseOutput = (Map) output.get("sse_output"); + assertThat(sseOutput).containsKey("data"); + assertThat(sseOutput.get("streaming")).isEqualTo(true); + }) + .assertNext(output -> { + assertThat(output).containsKey("sse_output"); + Map sseOutput = (Map) output.get("sse_output"); + assertThat(sseOutput).containsKey("data"); + }) + .assertNext(output -> { + assertThat(output).containsKey("sse_output"); + Map sseOutput = (Map) output.get("sse_output"); + assertThat(sseOutput).containsKey("data"); + }) + .verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_JsonLines() throws Exception { + // 模拟JSON Lines响应 + String jsonLinesResponse = """ + {"event": "start", "data": "Processing request"} + {"event": "progress", "data": "50%"} + {"event": "complete", "data": "Finished"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + McpNode mcpNode = McpNode.builder() + .url(mockWebServer.url("/jsonlines").toString()) + .enableHttpStream(HttpMethod.POST, McpNode.StreamFormat.JSON_LINES) + .streamMode(McpNode.StreamMode.DISTRIBUTE) + .outputKey("jsonlines_output") + .allowInternalAddress(true) + .param("prompt", "${user_input}") + .readTimeout(Duration.ofSeconds(10)) + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("jsonlines_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result) + .assertNext(output -> { + assertThat(output).containsKey("jsonlines_output"); + Map jsonOutput = (Map) output.get("jsonlines_output"); + assertThat(jsonOutput).containsKey("data"); + assertThat(jsonOutput.get("streaming")).isEqualTo(true); + }) + .assertNext(output -> { + assertThat(output).containsKey("jsonlines_output"); + }) + .assertNext(output -> { + assertThat(output).containsKey("jsonlines_output"); + }) + .verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_TextStream() throws Exception { + // 模拟文本流响应 + String textStreamResponse = "chunk1\nchunk2\nchunk3\n"; + + mockWebServer.enqueue(new MockResponse().setBody(textStreamResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE) + .setResponseCode(200)); + + McpNode mcpNode = McpNode.builder() + .url(mockWebServer.url("/text").toString()) + .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.TEXT_STREAM) + .streamMode(McpNode.StreamMode.DISTRIBUTE) + .delimiter("\n") + .outputKey("text_output") + .allowInternalAddress(true) + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("text_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result) + .assertNext(output -> { + assertThat(output).containsKey("text_output"); + Map textOutput = (Map) output.get("text_output"); + assertThat(textOutput).containsKey("data"); + assertThat(textOutput.get("data")).isEqualTo("chunk1"); + }) + .assertNext(output -> { + Map textOutput = (Map) output.get("text_output"); + assertThat(textOutput.get("data")).isEqualTo("chunk2"); + }) + .assertNext(output -> { + Map textOutput = (Map) output.get("text_output"); + assertThat(textOutput.get("data")).isEqualTo("chunk3"); + }) + .verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_AggregateMode() throws Exception { + // 测试聚合模式 + String jsonLinesResponse = """ + {"id": 1, "message": "First"} + {"id": 2, "message": "Second"} + {"id": 3, "message": "Third"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + McpNode mcpNode = McpNode.builder() + .url(mockWebServer.url("/aggregate").toString()) + .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.JSON_LINES) + .streamMode(McpNode.StreamMode.AGGREGATE) + .outputKey("aggregated_output") + .allowInternalAddress(true) + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("aggregated_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result) + .assertNext(output -> { + assertThat(output).containsKey("aggregated_output"); + Map aggregatedOutput = (Map) output.get("aggregated_output"); + assertThat(aggregatedOutput).containsKey("data"); + assertThat(aggregatedOutput.get("streaming")).isEqualTo(false); + assertThat(aggregatedOutput.get("aggregated")).isEqualTo(true); + assertThat(aggregatedOutput.get("count")).isEqualTo(3); + }) + .verifyComplete(); + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testMcpNodeBackwardCompatibility_McpSyncMode() throws Exception { + // 测试向后兼容性 - 默认MCP同步模式应该仍然工作 + McpNode mcpNode = McpNode.builder() + .url("http://localhost:8080") + .tool("test_tool") + .param("input", "${user_input}") + .outputKey("mcp_result") + .build(); + + // 验证默认是MCP_SYNC模式 + // 注意：这个测试会失败，因为没有真实的MCP服务器，但能验证配置正确 + try { + CompletableFuture> future = mcpNode.apply(testState); + Map result = future.get(5, TimeUnit.SECONDS); + // 应该返回错误信息 + assertThat(result).containsKey("mcp_result"); + Map mcpResult = (Map) result.get("mcp_result"); + assertThat(mcpResult).containsKey("error"); + } catch (Exception e) { + // 预期会有连接异常，说明配置正确 + assertThat(e.getCause().getMessage()).containsAnyOf("Connection refused", "connection was refused", "Unable to connect", "Failed to wait"); + } + } + + @Test + @Timeout(value = 30, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_VariableReplacement() throws Exception { + // 测试变量替换功能 + String jsonResponse = """ + {"result": "success"} + """; + + mockWebServer.enqueue(new MockResponse().setBody(jsonResponse) + .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) + .setResponseCode(200)); + + // 使用包含变量的URL + String urlTemplate = mockWebServer.url("/api").toString() + "?input=${user_input}&key=${test_key}"; + + McpNode mcpNode = McpNode.builder() + .url(urlTemplate) + .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.JSON_LINES) + .streamMode(McpNode.StreamMode.DISTRIBUTE) + .outputKey("variable_output") + .header("X-Custom-Header", "${test_key}") + .allowInternalAddress(true) + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("variable_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result) + .assertNext(output -> { + assertThat(output).containsKey("variable_output"); + Map variableOutput = (Map) output.get("variable_output"); + assertThat(variableOutput).containsKey("data"); + }) + .verifyComplete(); + + // 验证请求是否正确替换了变量 + var recordedRequest = mockWebServer.takeRequest(); + assertThat(recordedRequest.getPath()).contains("input=Hello%20World"); + assertThat(recordedRequest.getPath()).contains("key=test_value"); + assertThat(recordedRequest.getHeader("X-Custom-Header")).isEqualTo("test_value"); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_ErrorHandling() throws Exception { + // 测试错误处理 + mockWebServer.enqueue(new MockResponse().setResponseCode(500).setBody("Internal Server Error")); + + McpNode mcpNode = McpNode.builder() + .url(mockWebServer.url("/error").toString()) + .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.SSE) + .streamMode(McpNode.StreamMode.DISTRIBUTE) + .outputKey("error_output") + .readTimeout(Duration.ofSeconds(2)) + .allowInternalAddress(true) + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("error_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result) + .assertNext(output -> { + assertThat(output).containsKey("error_output"); + Map errorOutput = (Map) output.get("error_output"); + assertThat(errorOutput).containsKey("error"); + assertThat(errorOutput.get("streaming")).isEqualTo(false); + String errorMessage = errorOutput.get("error").toString(); + assertThat(errorMessage).satisfiesAnyOf( + msg -> assertThat(msg).containsIgnoringCase("500"), + msg -> assertThat(msg).containsIgnoringCase("HTTP"), + msg -> assertThat(msg).containsIgnoringCase("Internal Server Error") + ); + }) + .verifyComplete(); + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testMcpNodeBuilderConvenienceMethods() { + // 测试便捷方法 + McpNode node1 = McpNode.builder() + .url("http://example.com/stream") + .enableHttpStream() + .build(); + + // 验证默认配置 + assertThat(node1).isNotNull(); + + McpNode node2 = McpNode.builder() + .url("http://example.com/chat") + .enableHttpStream(HttpMethod.POST, McpNode.StreamFormat.JSON_LINES) + .build(); + + assertThat(node2).isNotNull(); + } + + @Test + @Timeout(value = 10, unit = TimeUnit.SECONDS) + void testMcpNodeBuilderValidation() { + // 测试构建器验证 + try { + McpNode.builder().build(); + assertThat(false).as("Should throw IllegalArgumentException for missing URL").isTrue(); + } catch (IllegalArgumentException e) { + assertThat(e.getMessage()).contains("URL cannot be null or empty"); + } + + try { + McpNode.builder() + .url("http://example.com") + .processMode(McpNode.McpProcessMode.MCP_SYNC) + .build(); + assertThat(false).as("Should throw IllegalArgumentException for missing tool in MCP_SYNC mode").isTrue(); + } catch (IllegalArgumentException e) { + assertThat(e.getMessage()).contains("Tool name is required for MCP_SYNC mode"); + } + } + + @Test + @Timeout(value = 15, unit = TimeUnit.SECONDS) + void testMcpNodeHttpStreamMode_SecurityValidation() throws Exception { + // 测试安全验证 - 拒绝内网地址 + McpNode mcpNode = McpNode.builder() + .url("http://192.168.1.1/test") + .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.JSON_LINES) + .allowInternalAddress(false) // 禁止内网访问 + .webClient(WebClient.create()) + .build(); + + CompletableFuture> future = mcpNode.apply(testState); + Map asyncResult = future.get(10, TimeUnit.SECONDS); + AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("stream_output"); + Flux> result = Flux.fromStream(generator.stream()); + + StepVerifier.create(result.timeout(Duration.ofSeconds(5))) + .assertNext(output -> { + assertThat(output).containsKey("error"); + assertThat(output.get("error").toString()).contains("Internal network access not allowed"); + }) + .verifyComplete(); + } + +} diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java deleted file mode 100644 index 4909ef62eb..0000000000 --- a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/streaming/StreamHttpNodeTest.java +++ /dev/null @@ -1,779 +0,0 @@ -/* - * Copyright 2024-2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.alibaba.cloud.ai.graph.streaming; - -import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.OverAllStateBuilder; -import com.alibaba.cloud.ai.graph.async.AsyncGenerator; -import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamFormat; -import com.alibaba.cloud.ai.graph.streaming.StreamHttpNodeParam.StreamMode; -import okhttp3.mockwebserver.MockResponse; -import okhttp3.mockwebserver.MockWebServer; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.Timeout; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpMethod; -import org.springframework.http.MediaType; -import org.springframework.web.reactive.function.client.WebClient; -import reactor.core.publisher.Flux; -import reactor.test.StepVerifier; - -import java.io.IOException; -import java.time.Duration; -import java.util.List; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.TimeUnit; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * StreamHttpNode单元测试 - */ -class StreamHttpNodeTest { - - private MockWebServer mockWebServer; - - private StreamHttpNode streamHttpNode; - - private OverAllState testState; - - @BeforeEach - void setUp() throws IOException { - mockWebServer = new MockWebServer(); - mockWebServer.start(); - - testState = OverAllStateBuilder.builder() - .putData("test_key", "test_value") - .putData("user_input", "Hello World") - .build(); - } - - @AfterEach - void tearDown() throws IOException { - if (mockWebServer != null) { - mockWebServer.shutdown(); - } - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testSSEStreamProcessing() throws Exception { - // 模拟SSE响应 - String sseResponse = """ - data: {"type": "message", "content": "Hello"} - - data: {"type": "message", "content": "World"} - - data: {"type": "done"} - - data: [DONE] - - """; - - mockWebServer.enqueue(new MockResponse().setBody(sseResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/sse").toString()) - .streamFormat(StreamFormat.SSE) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("sse_output") - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("sse_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("sse_output"); - Map sseOutput = (Map) output.get("sse_output"); - assertThat(sseOutput).containsKey("data"); - assertThat(sseOutput.get("streaming")).isEqualTo(true); - }).assertNext(output -> { - assertThat(output).containsKey("sse_output"); - Map sseOutput = (Map) output.get("sse_output"); - assertThat(sseOutput).containsKey("data"); - }).assertNext(output -> { - assertThat(output).containsKey("sse_output"); - Map sseOutput = (Map) output.get("sse_output"); - assertThat(sseOutput).containsKey("data"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testJsonLinesStreamProcessing() throws Exception { - // 模拟JSON Lines响应 - String jsonLinesResponse = """ - {"event": "start", "data": "Processing request"} - {"event": "progress", "data": "50%"} - {"event": "complete", "data": "Finished"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.POST) - .url(mockWebServer.url("/jsonlines").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("jsonlines_output") - .readTimeout(Duration.ofSeconds(10)) - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("jsonlines_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("jsonlines_output"); - Map jsonOutput = (Map) output.get("jsonlines_output"); - assertThat(jsonOutput).containsKey("data"); - assertThat(jsonOutput.get("streaming")).isEqualTo(true); - }).assertNext(output -> { - assertThat(output).containsKey("jsonlines_output"); - Map jsonOutput = (Map) output.get("jsonlines_output"); - assertThat(jsonOutput).containsKey("data"); - }).assertNext(output -> { - assertThat(output).containsKey("jsonlines_output"); - Map jsonOutput = (Map) output.get("jsonlines_output"); - assertThat(jsonOutput).containsKey("data"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testTextStreamProcessing() throws Exception { - // 模拟文本流响应 - String textStreamResponse = "chunk1\nchunk2\nchunk3\n"; - - mockWebServer.enqueue(new MockResponse().setBody(textStreamResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/text").toString()) - .streamFormat(StreamFormat.TEXT_STREAM) - .streamMode(StreamMode.DISTRIBUTE) - .delimiter("\n") - .outputKey("text_output") - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("text_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("text_output"); - Map textOutput = (Map) output.get("text_output"); - assertThat(textOutput).containsKey("data"); - assertThat(textOutput.get("data")).isEqualTo("chunk1"); - }).assertNext(output -> { - Map textOutput = (Map) output.get("text_output"); - assertThat(textOutput.get("data")).isEqualTo("chunk2"); - }).assertNext(output -> { - Map textOutput = (Map) output.get("text_output"); - assertThat(textOutput.get("data")).isEqualTo("chunk3"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testAggregateMode() throws Exception { - // 模拟多个JSON对象的响应 - String jsonLinesResponse = """ - {"id": 1, "message": "First"} - {"id": 2, "message": "Second"} - {"id": 3, "message": "Third"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/aggregate").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.AGGREGATE) - .outputKey("aggregated_output") - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("aggregated_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("aggregated_output"); - Map aggregatedOutput = (Map) output.get("aggregated_output"); - assertThat(aggregatedOutput).containsKey("data"); - assertThat(aggregatedOutput.get("streaming")).isEqualTo(false); - assertThat(aggregatedOutput.get("aggregated")).isEqualTo(true); - assertThat(aggregatedOutput.get("count")).isEqualTo(3); - - List dataList = (List) aggregatedOutput.get("data"); - assertThat(dataList).hasSize(3); - }).verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testVariableReplacement() throws Exception { - // 测试URL中的变量替换 - String jsonResponse = """ - {"result": "success"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - // 使用包含变量的URL - String urlTemplate = mockWebServer.url("/api").toString() + "?input=${user_input}&key=${test_key}"; - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(urlTemplate) - .header("X-Custom-Header", "${test_key}") - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("variable_output") - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("variable_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("variable_output"); - Map variableOutput = (Map) output.get("variable_output"); - assertThat(variableOutput).containsKey("data"); - }).verifyComplete(); - - // 验证请求是否正确替换了变量 - var recordedRequest = mockWebServer.takeRequest(); - assertThat(recordedRequest.getPath()).contains("input=Hello%20World"); // URL编码后的空格 - assertThat(recordedRequest.getPath()).contains("key=test_value"); - assertThat(recordedRequest.getHeader("X-Custom-Header")).isEqualTo("test_value"); - } - - @Test - @Timeout(value = 10, unit = TimeUnit.SECONDS) - void testErrorHandling() throws Exception { - // 模拟服务器错误 - mockWebServer.enqueue(new MockResponse().setResponseCode(500).setBody("Internal Server Error")); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/error").toString()) - .streamFormat(StreamFormat.SSE) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("error_output") - .readTimeout(Duration.ofSeconds(2)) // 短超时 - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("error_output"); - Flux> result = Flux.fromStream(generator.stream()); - - // 期望收到包含错误信息的输出 - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("error_output"); - Map errorOutput = (Map) output.get("error_output"); - assertThat(errorOutput).containsKey("error"); - assertThat(errorOutput.get("streaming")).isEqualTo(false); - // 验证包含HTTP错误或超时信息 - String errorMessage = errorOutput.get("error").toString(); - assertThat(errorMessage).satisfiesAnyOf(msg -> assertThat(msg).containsIgnoringCase("500"), // HTTP状态码错误 - msg -> assertThat(msg).containsIgnoringCase("timeout"), // 超时错误 - msg -> assertThat(msg).containsIgnoringCase("HTTP"), // HTTP错误 - msg -> assertThat(msg).containsIgnoringCase("WebClient"), // WebClient错误 - msg -> assertThat(msg).containsIgnoringCase("Did not observe"), // Reactor - // timeout错误 - msg -> assertThat(msg).containsIgnoringCase("retryWhen") // Reactor - // retry错误 - ); - }).verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testWithoutOutputKey() throws Exception { - // 测试不使用outputKey的情况 - String sseResponse = """ - data: {"message": "test"} - - """; - - mockWebServer.enqueue(new MockResponse().setBody(sseResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/no-key").toString()) - .streamFormat(StreamFormat.SSE) - .streamMode(StreamMode.DISTRIBUTE) - .allowInternalAddress(true) // 允许访问localhost - // 不设置outputKey - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - // 没有outputKey时，直接返回数据 - assertThat(output).containsKey("data"); - assertThat(output.get("streaming")).isEqualTo(true); - }).verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testStateGraphIntegration() throws Exception { - // 测试StreamHttpNode与StateGraph的集成 - String chatResponse = """ - data: {"message": "Hello, how can I help you?", "type": "assistant"} - - data: {"message": "I'm here to assist with your questions.", "type": "assistant"} - - data: [DONE] - - """; - - mockWebServer.enqueue(new MockResponse().setBody(chatResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.POST) - .url(mockWebServer.url("/chat").toString()) - .streamFormat(StreamFormat.SSE) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("chat_response") - .header("Content-Type", "application/json") - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - // 测试流式执行 - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("chat_response"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("chat_response"); - Map chatOutput = (Map) output.get("chat_response"); - assertThat(chatOutput).containsKey("data"); - assertThat(chatOutput.get("streaming")).isEqualTo(true); - - // 验证数据格式 - Map data = (Map) chatOutput.get("data"); - assertThat(data).containsKey("message"); - assertThat(data).containsKey("type"); - assertThat(data.get("type")).isEqualTo("assistant"); - }).assertNext(output -> { - assertThat(output).containsKey("chat_response"); - Map chatOutput = (Map) output.get("chat_response"); - assertThat(chatOutput).containsKey("data"); - - Map data = (Map) chatOutput.get("data"); - assertThat(data.get("message")).isEqualTo("I'm here to assist with your questions."); - }).verifyComplete(); - - // 验证请求内容 - var recordedRequest = mockWebServer.takeRequest(); - assertThat(recordedRequest.getMethod()).isEqualTo("POST"); - assertThat(recordedRequest.getPath()).isEqualTo("/chat"); - assertThat(recordedRequest.getHeader("Content-Type")).isEqualTo("application/json"); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testStreamingWithHeaders() throws Exception { - // 测试带有自定义请求头的流式请求 - String streamResponse = """ - {"chunk": 1, "content": "First chunk"} - {"chunk": 2, "content": "Second chunk"} - {"chunk": 3, "content": "Final chunk"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(streamResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.POST) - .url(mockWebServer.url("/stream-with-auth").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("stream_data") - .header("Authorization", "Bearer ${test_key}") - .header("X-User-Agent", "StreamHttpNode/1.0") - .readTimeout(Duration.ofSeconds(30)) - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_data"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result).assertNext(output -> { - assertThat(output).containsKey("stream_data"); - Map streamOutput = (Map) output.get("stream_data"); - assertThat(streamOutput).containsKey("data"); - - Map data = (Map) streamOutput.get("data"); - assertThat(data.get("chunk")).isEqualTo(1); - assertThat(data.get("content")).isEqualTo("First chunk"); - }).assertNext(output -> { - Map streamOutput = (Map) output.get("stream_data"); - Map data = (Map) streamOutput.get("data"); - assertThat(data.get("chunk")).isEqualTo(2); - }).assertNext(output -> { - Map streamOutput = (Map) output.get("stream_data"); - Map data = (Map) streamOutput.get("data"); - assertThat(data.get("chunk")).isEqualTo(3); - assertThat(data.get("content")).isEqualTo("Final chunk"); - }).verifyComplete(); - - // 验证请求头 - var recordedRequest = mockWebServer.takeRequest(); - assertThat(recordedRequest.getHeader("Authorization")).isEqualTo("Bearer test_value"); - assertThat(recordedRequest.getHeader("X-User-Agent")).isEqualTo("StreamHttpNode/1.0"); - } - - @Test - @Timeout(value = 5, unit = TimeUnit.SECONDS) - void testBasicNodeCreation() { - // 测试StreamHttpNode的基本创建，不涉及网络请求 - try { - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .method(HttpMethod.GET) - .url("http://example.com/test") - .streamFormat(StreamFormat.SSE) - .streamMode(StreamMode.DISTRIBUTE) - .outputKey("test_output") - .build(); - - StreamHttpNode node = new StreamHttpNode(param); - assertThat(node).isNotNull(); - } - catch (Exception e) { - // 如果有任何异常，至少测试能够执行完成 - System.out.println("Exception caught: " + e.getMessage()); - } - } - - @Test - @Timeout(value = 3, unit = TimeUnit.SECONDS) - void testJustBasics() { - // 最基本的测试，不创建任何对象 - assertThat("hello").isEqualTo("hello"); - System.out.println("Basic test passed!"); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testSimpleHttpRequest() throws Exception { - // 测试简单的非流式HTTP请求 - String simpleResponse = "{\"result\": \"success\"}"; - - mockWebServer.enqueue(new MockResponse().setBody(simpleResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/simple").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.AGGREGATE) - .outputKey("simple_output") - .readTimeout(Duration.ofSeconds(5)) // 短超时 - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("simple_output"); - Flux> result = Flux.fromStream(generator.stream()); - - // 使用timeout()确保不会无限等待 - StepVerifier.create(result.timeout(Duration.ofSeconds(10))).assertNext(output -> { - assertThat(output).containsKey("simple_output"); - }).verifyComplete(); - } - - // ==================== 新增的改进功能测试 ==================== - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testUrlValidation_ShouldRejectInternalAddress() throws Exception { - // 测试URL安全验证 - 拒绝内网地址 - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url("http://192.168.1.1/test") // 内网地址 - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .allowInternalAddress(false) // 禁止内网访问 - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { - // 验证返回错误信息 - assertThat(output).containsKey("error"); - assertThat(output.get("error").toString()).contains("Internal network access not allowed"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testUrlValidation_ShouldAllowInternalAddressWhenConfigured() throws Exception { - // 测试URL安全验证 - 配置允许时可以访问内网地址 - mockWebServer.enqueue(new MockResponse().setBody("{\"internal\": \"success\"}") - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/internal").toString()) // 本地mock服务器 - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .allowInternalAddress(true) // 允许内网访问 - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { - // 验证正常处理 - assertThat(output).containsKey("data"); - assertThat(output.get("streaming")).isEqualTo(true); - }).verifyComplete(); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testJsonLinesWithErrorHandling() throws Exception { - // 测试改进的JSON解析错误处理 - String jsonLinesWithError = """ - {"valid": "json"} - {invalid json line - {"another": "valid"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonLinesWithError) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/jsonlines-error").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { - // 第一个有效JSON - assertThat(output).containsKey("data"); - Map data = (Map) output.get("data"); - assertThat(data).containsKey("valid"); - }).assertNext(output -> { - // 解析错误的JSON，应该包含错误信息 - assertThat(output).containsKey("data"); - Map data = (Map) output.get("data"); - assertThat(data).containsKey("_parsing_error"); - assertThat(data).containsKey("_raw_data"); - }).assertNext(output -> { - // 第三个有效JSON - assertThat(output).containsKey("data"); - Map data = (Map) output.get("data"); - assertThat(data).containsKey("another"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testCustomBufferTimeout() throws Exception { - // 测试自定义缓冲超时配置 - String streamResponse = """ - {"chunk": 1} - {"chunk": 2} - {"chunk": 3} - """; - - mockWebServer.enqueue(new MockResponse().setBody(streamResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/buffer-test").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .bufferTimeout(Duration.ofMillis(50)) // 自定义缓冲超时 - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { - assertThat(output).containsKey("data"); - assertThat(output.get("streaming")).isEqualTo(true); - }).assertNext(output -> { - assertThat(output).containsKey("data"); - }).assertNext(output -> { - assertThat(output).containsKey("data"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testInvalidProtocolValidation() throws Exception { - // 测试协议验证 - 拒绝非HTTP/HTTPS协议 - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url("ftp://example.com/test") // 不支持的协议 - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { - // 验证返回错误信息 - assertThat(output).containsKey("error"); - assertThat(output.get("error").toString()).contains("Only HTTP/HTTPS protocols are supported"); - }).verifyComplete(); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testStructuredErrorLogging() throws Exception { - // 测试结构化错误日志记录 - mockWebServer.enqueue(new MockResponse().setResponseCode(500).setBody("Internal Server Error")); - - StreamHttpNodeParam param = StreamHttpNodeParam.builder() - .webClient(WebClient.create()) - .method(HttpMethod.GET) - .url(mockWebServer.url("/error").toString()) - .streamFormat(StreamFormat.JSON_LINES) - .streamMode(StreamMode.DISTRIBUTE) - .allowInternalAddress(true) // 允许访问localhost - .build(); - - streamHttpNode = new StreamHttpNode(param); - - CompletableFuture> future = streamHttpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator generator = (AsyncGenerator) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))).assertNext(output -> { - // 验证错误输出格式 - assertThat(output).containsKey("error"); - assertThat(output.get("streaming")).isEqualTo(false); - assertThat(output).containsKey("timestamp"); - }).verifyComplete(); - } - -} From bcb8bf4d0300f0eaa495d713138b2cdde1ae2dc5 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Tue, 23 Sep 2025 23:48:36 +0800 Subject: [PATCH 10/11] feat: use Decorator that adds streaming HTTP capabilities to McpNode --- .../alibaba/cloud/ai/graph/node/McpNode.java | 590 +----------------- .../ai/graph/node/StreamableMcpNode.java | 174 ++++++ .../ai/graph/node/McpNodeHttpStreamTest.java | 423 ------------- .../ai/graph/node/StreamableMcpNodeTest.java | 233 +++++++ 4 files changed, 428 insertions(+), 992 deletions(-) create mode 100644 spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNode.java delete mode 100644 spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java create mode 100644 spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNodeTest.java diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java index d5c773da38..e5446dcf1c 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/McpNode.java @@ -17,11 +17,7 @@ package com.alibaba.cloud.ai.graph.node; import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.action.AsyncNodeAction; -import com.alibaba.cloud.ai.graph.async.AsyncGenerator; -import com.fasterxml.jackson.core.JsonProcessingException; -import com.fasterxml.jackson.databind.JsonNode; -import com.fasterxml.jackson.databind.ObjectMapper; +import com.alibaba.cloud.ai.graph.action.NodeAction; import io.modelcontextprotocol.client.McpClient; import io.modelcontextprotocol.client.McpSyncClient; import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport; @@ -31,110 +27,38 @@ import io.modelcontextprotocol.spec.McpSchema.TextContent; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.springframework.core.io.buffer.DataBuffer; -import org.springframework.http.HttpMethod; -import org.springframework.http.MediaType; import org.springframework.util.CollectionUtils; import org.springframework.util.StringUtils; -import org.springframework.web.reactive.function.client.WebClient; -import org.springframework.web.reactive.function.client.WebClientResponseException; -import org.springframework.web.util.UriComponentsBuilder; -import reactor.core.publisher.Flux; -import reactor.util.retry.Retry; - -import java.net.URI; -import java.nio.charset.StandardCharsets; -import java.time.Duration; -import java.util.ArrayList; + import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.concurrent.CompletableFuture; import java.util.regex.Matcher; import java.util.regex.Pattern; /** - * MCP Node: 多通道处理节点，支持 MCP 协议和 HTTP 流式处理 - * 作为图编排中的能力聚合和分发枢纽 + * MCP Node: Node for calling MCP Server */ -public class McpNode implements AsyncNodeAction { +public class McpNode implements NodeAction { private static final Pattern VARIABLE_PATTERN = Pattern.compile("\\$\\{(.+?)\\}"); - private static final Pattern SSE_DATA_PATTERN = Pattern.compile("^data: (.*)$", Pattern.MULTILINE); - - private static final ObjectMapper objectMapper = new ObjectMapper(); - private static final Logger log = LoggerFactory.getLogger(McpNode.class); - // 处理模式枚举 - public enum McpProcessMode { - /** - * MCP 同步模式 - 原有功能 - */ - MCP_SYNC, - /** - * HTTP 流式模式 - 新增能力 - */ - HTTP_STREAM - } - - /** - * 流格式枚举 - */ - public enum StreamFormat { - /** - * Server-Sent Events格式 - */ - SSE, - /** - * JSON Lines格式 (每行一个JSON对象) - */ - JSON_LINES, - /** - * 纯文本流，按分隔符分割 - */ - TEXT_STREAM - } - - /** - * 流处理模式枚举 - */ - public enum StreamMode { - /** - * 分发模式：流中的每个元素都触发下游节点执行 - */ - DISTRIBUTE, - /** - * 聚合模式：收集完整流后再执行下游节点 - */ - AGGREGATE - } - - // 原有 MCP 配置 private final String url; + private final String tool; + private final Map headers; + private final Map params; + private final String outputKey; + private final List inputParamKeys; - // 处理模式配置 - private final McpProcessMode processMode; - - // HTTP 流式处理配置 - private final HttpMethod httpMethod; - private final Map queryParams; - private final StreamFormat streamFormat; - private final StreamMode streamMode; - private final Duration readTimeout; - private final boolean allowInternalAddress; - private final Duration bufferTimeout; - private final String delimiter; - private final WebClient webClient; - - // MCP 客户端（仅在 MCP_SYNC 模式使用） private HttpClientSseClientTransport transport; + private McpSyncClient client; private McpNode(Builder builder) { @@ -144,42 +68,12 @@ private McpNode(Builder builder) { this.params = builder.params; this.outputKey = builder.outputKey; this.inputParamKeys = builder.inputParamKeys; - - // 处理模式配置 - this.processMode = builder.processMode; - - // HTTP 流式处理配置 - this.httpMethod = builder.httpMethod; - this.queryParams = builder.queryParams; - this.streamFormat = builder.streamFormat; - this.streamMode = builder.streamMode; - this.readTimeout = builder.readTimeout; - this.allowInternalAddress = builder.allowInternalAddress; - this.bufferTimeout = builder.bufferTimeout; - this.delimiter = builder.delimiter; - this.webClient = builder.webClient; } @Override - public CompletableFuture> apply(OverAllState state) { - try { - // 根据处理模式路由到不同的处理逻辑 - return switch (processMode) { - case MCP_SYNC -> handleMcpSync(state); - case HTTP_STREAM -> handleHttpStream(state); - }; - } catch (Exception e) { - log.error("[McpNode] Execution failed: mode={}, error={}", processMode, e.getMessage(), e); - return CompletableFuture.completedFuture(createErrorOutput(e)); - } - } - - /** - * 处理 MCP 同步模式 - 保持原有逻辑 - */ - private CompletableFuture> handleMcpSync(OverAllState state) throws Exception { + public Map apply(OverAllState state) throws Exception { log.info( - "[McpNode] Start executing MCP sync, original configuration: url={}, tool={}, headers={}, inputParamKeys={}", + "[McpNode] Start executing apply, original configuration: url={}, tool={}, headers={}, inputParamKeys={}", url, tool, headers, inputParamKeys); // Build transport and client @@ -255,349 +149,8 @@ else if (first instanceof Map map && map.containsKey("text")) { updatedState.put(this.outputKey, content); } } - log.info("[McpNode] MCP sync result: {}", updatedState); - return CompletableFuture.completedFuture(updatedState); - } - - /** - * 处理 HTTP 流式模式 - */ - private CompletableFuture> handleHttpStream(OverAllState state) { - try { - // 获取流式数据并转换为AsyncGenerator - Flux> streamFlux = executeStreaming(state); - - // 将Flux转换为AsyncGenerator，供图框架处理流式数据 - AsyncGenerator> generator = createAsyncGenerator(streamFlux); - - // 返回包含AsyncGenerator的结果Map - String outputKey = this.outputKey != null ? this.outputKey : "stream_output"; - return CompletableFuture.completedFuture(Map.of(outputKey, generator)); - } - catch (Exception e) { - log.error("[McpNode] HTTP stream initialization failed: url={}, method={}, error={}", url, - httpMethod, e.getMessage(), e); - // 返回包含错误信息的AsyncGenerator而不是直接返回Map - String outputKey = this.outputKey != null ? this.outputKey : "stream_output"; - Flux> errorFlux = Flux.just(createErrorOutput(e)); - AsyncGenerator> errorGenerator = createAsyncGenerator(errorFlux); - return CompletableFuture.completedFuture(Map.of(outputKey, errorGenerator)); - } - } - - /** - * 执行流式HTTP请求 - */ - private Flux> executeStreaming(OverAllState state) throws Exception { - String finalUrl = replaceVariables(this.url, state); - Map finalHeaders = replaceVariables(this.headers, state); - Map finalQueryParams = replaceVariables(this.queryParams, state); - - UriComponentsBuilder uriBuilder = UriComponentsBuilder.fromHttpUrl(finalUrl); - finalQueryParams.forEach(uriBuilder::queryParam); - URI finalUri = uriBuilder.build().toUri(); - - validateUrl(finalUri.toString()); - - WebClient.RequestBodySpec requestSpec = webClient - .method(httpMethod) - .uri(finalUri) - .headers(headers -> headers.setAll(finalHeaders)); - - // 处理请求体 - if (params != null && !params.isEmpty()) { - Map finalParams = replaceVariablesObj(params, state); - requestSpec.headers(h -> h.setContentType(MediaType.APPLICATION_JSON)); - requestSpec.bodyValue(finalParams); - } - - // 直接返回处理后的结果，将HTTP错误转换为错误数据项 - return requestSpec.exchangeToFlux(response -> { - if (!response.statusCode().is2xxSuccessful()) { - // 处理HTTP错误 - return response.bodyToMono(String.class) - .defaultIfEmpty("HTTP Error") - .map(errorBody -> { - WebClientResponseException exception = new WebClientResponseException( - response.statusCode().value(), "HTTP " + response.statusCode() + ": " + errorBody, - null, null, null); - return createErrorOutput(exception); - }) - .flux(); - } - - // 处理成功响应 - Flux dataBufferFlux = response.bodyToFlux(DataBuffer.class); - return processStreamResponse(dataBufferFlux, state); - }) - .retryWhen(Retry.backoff(3, Duration.ofMillis(1000))) // 默认重试配置 - .timeout(readTimeout) - .onErrorResume(throwable -> { - log.error("[McpNode] HTTP stream execution failed: url={}, method={}, error={}", finalUrl, - httpMethod, throwable.getMessage(), throwable); - return Flux.just(createErrorOutput(throwable)); - }); - } - - /** - * 将Flux转换为AsyncGenerator - */ - private AsyncGenerator> createAsyncGenerator(Flux> flux) { - return new AsyncGenerator>() { - private final java.util.concurrent.BlockingQueue>> queue = - new java.util.concurrent.LinkedBlockingQueue<>(); - - { - // 异步处理Flux数据 - flux.subscribe( - data -> queue.offer(AsyncGenerator.Data.of(CompletableFuture.completedFuture(data))), - error -> queue.offer(AsyncGenerator.Data.error(error)), - () -> queue.offer(AsyncGenerator.Data.done()) - ); - } - - @Override - public AsyncGenerator.Data> next() { - try { - return queue.take(); - } catch (InterruptedException e) { - Thread.currentThread().interrupt(); - return AsyncGenerator.Data.error(e); - } - } - }; - } - - /** - * 处理流式响应数据 - */ - private Flux> processStreamResponse(Flux responseFlux, OverAllState state) { - return responseFlux.map(dataBuffer -> { - byte[] bytes = new byte[dataBuffer.readableByteCount()]; - dataBuffer.read(bytes); - return new String(bytes, StandardCharsets.UTF_8); - }) - .buffer(bufferTimeout) - .map(chunks -> String.join("", chunks)) - .flatMap(this::parseStreamChunk) - .filter(data -> { - if (data instanceof String) { - return !((String) data).isEmpty(); - } - return data != null; - }) - .map(this::wrapOutput) - .transform(flux -> { - if (streamMode == StreamMode.AGGREGATE) { - return flux.collectList().map(this::aggregateResults).flux(); - } - return flux; - }) - .onErrorResume(error -> { - log.error("[McpNode] Error processing stream response", error); - return Flux.just(createErrorOutput(error)); - }); - } - - /** - * 解析流数据块 - */ - private Flux parseStreamChunk(String chunk) { - return switch (streamFormat) { - case SSE -> parseSSEChunk(chunk).cast(Object.class); - case JSON_LINES -> parseJsonLinesChunk(chunk); - case TEXT_STREAM -> parseTextStreamChunk(chunk).cast(Object.class); - }; - } - - /** - * 解析SSE格式数据 - */ - private Flux parseSSEChunk(String chunk) { - List results = new ArrayList<>(); - Matcher matcher = SSE_DATA_PATTERN.matcher(chunk); - - while (matcher.find()) { - String data = matcher.group(1).trim(); - if (!data.isEmpty() && !"[DONE]".equals(data)) { - results.add(data); - } - } - - return Flux.fromIterable(results); - } - - /** - * 解析JSON Lines格式数据 - */ - private Flux parseJsonLinesChunk(String chunk) { - String[] lines = chunk.split("\n"); - List results = new ArrayList<>(); - - for (String line : lines) { - line = line.trim(); - if (!line.isEmpty()) { - try { - objectMapper.readTree(line); - results.add(line); - } - catch (JsonProcessingException e) { - log.warn("[McpNode] Invalid JSON line: {}, error: {}", line, e.getMessage()); - Map errorMap = new HashMap<>(); - errorMap.put("_parsing_error", e.getMessage()); - errorMap.put("_raw_data", line); - results.add(errorMap); - } - } - } - - return Flux.fromIterable(results); - } - - /** - * 解析文本流数据 - */ - private Flux parseTextStreamChunk(String chunk) { - String[] parts = chunk.split(Pattern.quote(delimiter)); - List results = new ArrayList<>(); - - for (String part : parts) { - part = part.trim(); - if (!part.isEmpty()) { - results.add(part); - } - } - - return Flux.fromIterable(results); - } - - /** - * 包装输出数据 - */ - private Map wrapOutput(Object data) { - Map result = new HashMap<>(); - - if (data instanceof Map) { - result.put("data", data); - } - else if (data instanceof String) { - String stringData = (String) data; - try { - if (stringData.startsWith("{") || stringData.startsWith("[")) { - JsonNode jsonNode = objectMapper.readTree(stringData); - Object parsedData = objectMapper.convertValue(jsonNode, Object.class); - result.put("data", parsedData); - } - else { - result.put("data", stringData); - } - } - catch (JsonProcessingException e) { - result.put("data", stringData); - } - } - else { - result.put("data", data); - } - - result.put("timestamp", System.currentTimeMillis()); - result.put("streaming", true); - - if (StringUtils.hasLength(outputKey)) { - Map keyedResult = new HashMap<>(); - keyedResult.put(outputKey, result); - return keyedResult; - } - - return result; - } - - /** - * 聚合模式下的结果汇总 - */ - private Map aggregateResults(List> results) { - Map aggregated = new HashMap<>(); - List dataList = new ArrayList<>(); - - for (Map result : results) { - if (outputKey != null && result.containsKey(outputKey)) { - Map keyedData = (Map) result.get(outputKey); - dataList.add(keyedData.get("data")); - } - else { - dataList.add(result.get("data")); - } - } - - aggregated.put("data", dataList); - aggregated.put("count", results.size()); - aggregated.put("streaming", false); - aggregated.put("aggregated", true); - aggregated.put("timestamp", System.currentTimeMillis()); - - if (StringUtils.hasLength(outputKey)) { - Map keyedResult = new HashMap<>(); - keyedResult.put(outputKey, aggregated); - return keyedResult; - } - - return aggregated; - } - - /** - * 创建错误输出 - */ - private Map createErrorOutput(Throwable error) { - Map errorResult = new HashMap<>(); - errorResult.put("error", error.getMessage()); - errorResult.put("timestamp", System.currentTimeMillis()); - errorResult.put("streaming", false); - - if (StringUtils.hasLength(outputKey)) { - Map keyedResult = new HashMap<>(); - keyedResult.put(outputKey, errorResult); - return keyedResult; - } - - return errorResult; - } - - /** - * URL安全验证 - */ - private void validateUrl(String url) { - try { - URI uri = URI.create(url); - String host = uri.getHost(); - - if (host == null) { - throw new IllegalArgumentException("Invalid URL: missing host"); - } - - // 检查内网地址访问权限 - if (isInternalAddress(host) && !allowInternalAddress) { - throw new SecurityException( - "Internal network access not allowed: " + host + ". Set allowInternalAddress=true to enable."); - } - - // 验证协议 - String scheme = uri.getScheme(); - if (!"http".equalsIgnoreCase(scheme) && !"https".equalsIgnoreCase(scheme)) { - throw new IllegalArgumentException("Only HTTP/HTTPS protocols are supported: " + scheme); - } - - } - catch (IllegalArgumentException | SecurityException e) { - throw new McpNodeException("URL validation failed: " + e.getMessage(), e); - } - } - - /** - * 检查是否为内网地址 - */ - private boolean isInternalAddress(String host) { - return host.startsWith("127.") || host.startsWith("10.") || host.startsWith("192.168.") - || host.matches("172\\.(1[6-9]|2[0-9]|3[0-1])\\..*") || "localhost".equalsIgnoreCase(host); + log.info("[McpNode] update state: {}", updatedState); + return updatedState; } private String replaceVariables(String template, OverAllState state) { @@ -608,20 +161,13 @@ private String replaceVariables(String template, OverAllState state) { while (matcher.find()) { String key = matcher.group(1); Object value = state.value(key).orElse(""); - log.debug("[McpNode] replace param: {} -> {}", key, value); - matcher.appendReplacement(result, Matcher.quoteReplacement(value.toString())); + log.info("[McpNode] replace param: {} -> {}", key, value); + matcher.appendReplacement(result, value.toString()); } matcher.appendTail(result); return result.toString(); } - private Map replaceVariables(Map map, OverAllState state) { - if (map == null) return new HashMap<>(); - Map result = new HashMap<>(); - map.forEach((k, v) -> result.put(k, replaceVariables(v, state))); - return result; - } - private Map replaceVariablesObj(Map map, OverAllState state) { if (map == null) return null; @@ -643,27 +189,17 @@ public static Builder builder() { public static class Builder { - // 原有 MCP 配置 private String url; + private String tool; + private Map headers = new HashMap<>(); + private Map params = new HashMap<>(); - private String outputKey; - private List inputParamKeys; - // 处理模式配置 - private McpProcessMode processMode = McpProcessMode.MCP_SYNC; // 默认保持原有行为 + private String outputKey; - // HTTP 流式处理配置 - private HttpMethod httpMethod = HttpMethod.GET; - private Map queryParams = new HashMap<>(); - private StreamFormat streamFormat = StreamFormat.SSE; - private StreamMode streamMode = StreamMode.DISTRIBUTE; - private Duration readTimeout = Duration.ofMinutes(5); - private boolean allowInternalAddress = false; - private Duration bufferTimeout = Duration.ofMillis(100); - private String delimiter = "\n"; - private WebClient webClient = WebClient.create(); + private List inputParamKeys; public Builder url(String url) { this.url = url; @@ -695,91 +231,7 @@ public Builder inputParamKeys(List inputParamKeys) { return this; } - // 处理模式配置 - public Builder processMode(McpProcessMode processMode) { - this.processMode = processMode; - return this; - } - - // HTTP 流式处理配置方法 - public Builder httpMethod(HttpMethod httpMethod) { - this.httpMethod = httpMethod; - return this; - } - - public Builder queryParam(String name, String value) { - this.queryParams.put(name, value); - return this; - } - - public Builder queryParams(Map queryParams) { - this.queryParams.putAll(queryParams); - return this; - } - - public Builder streamFormat(StreamFormat streamFormat) { - this.streamFormat = streamFormat; - return this; - } - - public Builder streamMode(StreamMode streamMode) { - this.streamMode = streamMode; - return this; - } - - public Builder readTimeout(Duration readTimeout) { - this.readTimeout = readTimeout; - return this; - } - - public Builder allowInternalAddress(boolean allowInternalAddress) { - this.allowInternalAddress = allowInternalAddress; - return this; - } - - public Builder bufferTimeout(Duration bufferTimeout) { - this.bufferTimeout = bufferTimeout; - return this; - } - - public Builder delimiter(String delimiter) { - this.delimiter = delimiter; - return this; - } - - public Builder webClient(WebClient webClient) { - this.webClient = webClient; - return this; - } - - /** - * 便捷方法：启用HTTP流式模式 - */ - public Builder enableHttpStream() { - this.processMode = McpProcessMode.HTTP_STREAM; - return this; - } - - /** - * 便捷方法：启用HTTP流式模式并设置基本参数 - */ - public Builder enableHttpStream(HttpMethod method, StreamFormat format) { - this.processMode = McpProcessMode.HTTP_STREAM; - this.httpMethod = method; - this.streamFormat = format; - return this; - } - public McpNode build() { - // 验证配置 - if (url == null || url.trim().isEmpty()) { - throw new IllegalArgumentException("URL cannot be null or empty"); - } - - if (processMode == McpProcessMode.MCP_SYNC && (tool == null || tool.trim().isEmpty())) { - throw new IllegalArgumentException("Tool name is required for MCP_SYNC mode"); - } - return new McpNode(this); } diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNode.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNode.java new file mode 100644 index 0000000000..def2540699 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNode.java @@ -0,0 +1,174 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.graph.node; + +import com.alibaba.cloud.ai.graph.OverAllState; +import com.alibaba.cloud.ai.graph.action.AsyncNodeAction; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.net.URI; +import java.net.http.HttpClient; +import java.net.http.HttpRequest; +import java.net.http.HttpResponse; +import java.time.Duration; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ForkJoinPool; + +/** + * Streamable MCP Node + */ +public class StreamableMcpNode implements AsyncNodeAction { + + private static final Logger log = LoggerFactory.getLogger(StreamableMcpNode.class); + + private final McpNode mcpNode; + private final String streamUrl; + private final StreamFormat format; + private final HttpClient httpClient; + + private StreamableMcpNode(Builder builder) { + this.mcpNode = builder.mcpNode; + this.streamUrl = builder.streamUrl; + this.format = builder.format; + this.httpClient = HttpClient.newBuilder() + .connectTimeout(Duration.ofSeconds(30)) + .executor(ForkJoinPool.commonPool()) + .build(); + } + + @Override + public CompletableFuture> apply(OverAllState state) { + return CompletableFuture.supplyAsync(() -> { + try { + return mcpNode.apply(state); + } catch (Exception e) { + log.error("[StreamableMcpNode] MCP call failed", e); + Map errorResult = new HashMap<>(); + errorResult.put("error", e.getMessage()); + errorResult.put("exception_type", e.getClass().getSimpleName()); + return errorResult; + } + }).thenCompose(mcpResult -> { + if (mcpResult.containsKey("error") || streamUrl == null) { + return CompletableFuture.completedFuture(mcpResult); + } + return executeStreamRequestAsync(mcpResult); + }); + } + + private CompletableFuture> executeStreamRequestAsync(Map mcpResult) { + try { + HttpRequest request = HttpRequest.newBuilder() + .uri(URI.create(streamUrl)) + .header("Accept", format.getContentType()) + .timeout(Duration.ofSeconds(60)) + .GET() + .build(); + + return httpClient.sendAsync(request, HttpResponse.BodyHandlers.ofString()) + .thenApply(response -> { + if (response.statusCode() < 200 || response.statusCode() >= 300) { + log.error("[StreamableMcpNode] HTTP error: {} {}", response.statusCode(), response.body()); + Map errorResult = new HashMap<>(mcpResult); + errorResult.put("error", "HTTP " + response.statusCode() + ": " + response.body()); + return errorResult; + } + + Map result = new HashMap<>(); + mcpResult.forEach(result::put); + result.put("stream_response", response.body()); + return result; + }) + .exceptionally(throwable -> { + log.error("[StreamableMcpNode] Stream request failed", throwable); + Map errorResult = new HashMap<>(mcpResult); + errorResult.put("error", throwable.getMessage()); + errorResult.put("exception_type", throwable.getClass().getSimpleName()); + return errorResult; + }); + } catch (Exception e) { + log.error("[StreamableMcpNode] Failed to create stream request", e); + Map errorResult = new HashMap<>(mcpResult); + errorResult.put("error", e.getMessage()); + errorResult.put("exception_type", e.getClass().getSimpleName()); + return CompletableFuture.completedFuture(errorResult); + } + } + + public static Builder builder() { + return new Builder(); + } + + public static class Builder { + private McpNode mcpNode; + private String streamUrl; + private StreamFormat format = StreamFormat.SSE; + + public Builder mcpNode(McpNode mcpNode) { + this.mcpNode = mcpNode; + return this; + } + + public Builder streamUrl(String streamUrl) { + this.streamUrl = streamUrl; + return this; + } + + public Builder format(StreamFormat format) { + this.format = format; + return this; + } + + public StreamableMcpNode build() { + if (mcpNode == null) { + throw new IllegalArgumentException("McpNode is required"); + } + if (streamUrl != null && !isValidUrl(streamUrl)) { + throw new IllegalArgumentException("Invalid streamUrl format: " + streamUrl); + } + return new StreamableMcpNode(this); + } + + private boolean isValidUrl(String url) { + try { + URI.create(url); + return url.startsWith("http://") || url.startsWith("https://"); + } catch (Exception e) { + return false; + } + } + } + + public enum StreamFormat { + SSE("text/event-stream"), + JSON_LINES("application/x-ndjson"), + TEXT_PLAIN("text/plain"); + + private final String contentType; + + StreamFormat(String contentType) { + this.contentType = contentType; + } + + public String getContentType() { + return contentType; + } + } +} diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java deleted file mode 100644 index ac7314ea34..0000000000 --- a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/McpNodeHttpStreamTest.java +++ /dev/null @@ -1,423 +0,0 @@ -/* - * Copyright 2024-2025 the original author or authors. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * https://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.alibaba.cloud.ai.graph.node; - -import com.alibaba.cloud.ai.graph.OverAllState; -import com.alibaba.cloud.ai.graph.OverAllStateBuilder; -import com.alibaba.cloud.ai.graph.async.AsyncGenerator; -import okhttp3.mockwebserver.MockResponse; -import okhttp3.mockwebserver.MockWebServer; -import org.junit.jupiter.api.AfterEach; -import org.junit.jupiter.api.BeforeEach; -import org.junit.jupiter.api.Test; -import org.junit.jupiter.api.Timeout; -import org.springframework.http.HttpHeaders; -import org.springframework.http.HttpMethod; -import org.springframework.http.MediaType; -import org.springframework.web.reactive.function.client.WebClient; -import reactor.core.publisher.Flux; -import reactor.test.StepVerifier; - -import java.io.IOException; -import java.time.Duration; -import java.util.Map; -import java.util.concurrent.CompletableFuture; -import java.util.concurrent.TimeUnit; - -import static org.assertj.core.api.Assertions.assertThat; - -/** - * McpNode HTTP流式功能测试 - */ -class McpNodeHttpStreamTest { - - private MockWebServer mockWebServer; - - private OverAllState testState; - - @BeforeEach - void setUp() throws IOException { - mockWebServer = new MockWebServer(); - mockWebServer.start(); - - testState = OverAllStateBuilder.builder() - .putData("test_key", "test_value") - .putData("user_input", "Hello World") - .build(); - } - - @AfterEach - void tearDown() throws IOException { - if (mockWebServer != null) { - mockWebServer.shutdown(); - } - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_SSE() throws Exception { - // 模拟SSE响应 - String sseResponse = """ - data: {"type": "message", "content": "Hello"} - - data: {"type": "message", "content": "World"} - - data: {"type": "done"} - - """; - - mockWebServer.enqueue(new MockResponse().setBody(sseResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_EVENT_STREAM_VALUE) - .setResponseCode(200)); - - McpNode mcpNode = McpNode.builder() - .url(mockWebServer.url("/sse").toString()) - .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.SSE) - .streamMode(McpNode.StreamMode.DISTRIBUTE) - .outputKey("sse_output") - .allowInternalAddress(true) - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("sse_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result) - .assertNext(output -> { - assertThat(output).containsKey("sse_output"); - Map sseOutput = (Map) output.get("sse_output"); - assertThat(sseOutput).containsKey("data"); - assertThat(sseOutput.get("streaming")).isEqualTo(true); - }) - .assertNext(output -> { - assertThat(output).containsKey("sse_output"); - Map sseOutput = (Map) output.get("sse_output"); - assertThat(sseOutput).containsKey("data"); - }) - .assertNext(output -> { - assertThat(output).containsKey("sse_output"); - Map sseOutput = (Map) output.get("sse_output"); - assertThat(sseOutput).containsKey("data"); - }) - .verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_JsonLines() throws Exception { - // 模拟JSON Lines响应 - String jsonLinesResponse = """ - {"event": "start", "data": "Processing request"} - {"event": "progress", "data": "50%"} - {"event": "complete", "data": "Finished"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - McpNode mcpNode = McpNode.builder() - .url(mockWebServer.url("/jsonlines").toString()) - .enableHttpStream(HttpMethod.POST, McpNode.StreamFormat.JSON_LINES) - .streamMode(McpNode.StreamMode.DISTRIBUTE) - .outputKey("jsonlines_output") - .allowInternalAddress(true) - .param("prompt", "${user_input}") - .readTimeout(Duration.ofSeconds(10)) - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("jsonlines_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result) - .assertNext(output -> { - assertThat(output).containsKey("jsonlines_output"); - Map jsonOutput = (Map) output.get("jsonlines_output"); - assertThat(jsonOutput).containsKey("data"); - assertThat(jsonOutput.get("streaming")).isEqualTo(true); - }) - .assertNext(output -> { - assertThat(output).containsKey("jsonlines_output"); - }) - .assertNext(output -> { - assertThat(output).containsKey("jsonlines_output"); - }) - .verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_TextStream() throws Exception { - // 模拟文本流响应 - String textStreamResponse = "chunk1\nchunk2\nchunk3\n"; - - mockWebServer.enqueue(new MockResponse().setBody(textStreamResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.TEXT_PLAIN_VALUE) - .setResponseCode(200)); - - McpNode mcpNode = McpNode.builder() - .url(mockWebServer.url("/text").toString()) - .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.TEXT_STREAM) - .streamMode(McpNode.StreamMode.DISTRIBUTE) - .delimiter("\n") - .outputKey("text_output") - .allowInternalAddress(true) - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("text_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result) - .assertNext(output -> { - assertThat(output).containsKey("text_output"); - Map textOutput = (Map) output.get("text_output"); - assertThat(textOutput).containsKey("data"); - assertThat(textOutput.get("data")).isEqualTo("chunk1"); - }) - .assertNext(output -> { - Map textOutput = (Map) output.get("text_output"); - assertThat(textOutput.get("data")).isEqualTo("chunk2"); - }) - .assertNext(output -> { - Map textOutput = (Map) output.get("text_output"); - assertThat(textOutput.get("data")).isEqualTo("chunk3"); - }) - .verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_AggregateMode() throws Exception { - // 测试聚合模式 - String jsonLinesResponse = """ - {"id": 1, "message": "First"} - {"id": 2, "message": "Second"} - {"id": 3, "message": "Third"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonLinesResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - McpNode mcpNode = McpNode.builder() - .url(mockWebServer.url("/aggregate").toString()) - .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.JSON_LINES) - .streamMode(McpNode.StreamMode.AGGREGATE) - .outputKey("aggregated_output") - .allowInternalAddress(true) - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("aggregated_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result) - .assertNext(output -> { - assertThat(output).containsKey("aggregated_output"); - Map aggregatedOutput = (Map) output.get("aggregated_output"); - assertThat(aggregatedOutput).containsKey("data"); - assertThat(aggregatedOutput.get("streaming")).isEqualTo(false); - assertThat(aggregatedOutput.get("aggregated")).isEqualTo(true); - assertThat(aggregatedOutput.get("count")).isEqualTo(3); - }) - .verifyComplete(); - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testMcpNodeBackwardCompatibility_McpSyncMode() throws Exception { - // 测试向后兼容性 - 默认MCP同步模式应该仍然工作 - McpNode mcpNode = McpNode.builder() - .url("http://localhost:8080") - .tool("test_tool") - .param("input", "${user_input}") - .outputKey("mcp_result") - .build(); - - // 验证默认是MCP_SYNC模式 - // 注意：这个测试会失败，因为没有真实的MCP服务器，但能验证配置正确 - try { - CompletableFuture> future = mcpNode.apply(testState); - Map result = future.get(5, TimeUnit.SECONDS); - // 应该返回错误信息 - assertThat(result).containsKey("mcp_result"); - Map mcpResult = (Map) result.get("mcp_result"); - assertThat(mcpResult).containsKey("error"); - } catch (Exception e) { - // 预期会有连接异常，说明配置正确 - assertThat(e.getCause().getMessage()).containsAnyOf("Connection refused", "connection was refused", "Unable to connect", "Failed to wait"); - } - } - - @Test - @Timeout(value = 30, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_VariableReplacement() throws Exception { - // 测试变量替换功能 - String jsonResponse = """ - {"result": "success"} - """; - - mockWebServer.enqueue(new MockResponse().setBody(jsonResponse) - .setHeader(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE) - .setResponseCode(200)); - - // 使用包含变量的URL - String urlTemplate = mockWebServer.url("/api").toString() + "?input=${user_input}&key=${test_key}"; - - McpNode mcpNode = McpNode.builder() - .url(urlTemplate) - .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.JSON_LINES) - .streamMode(McpNode.StreamMode.DISTRIBUTE) - .outputKey("variable_output") - .header("X-Custom-Header", "${test_key}") - .allowInternalAddress(true) - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("variable_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result) - .assertNext(output -> { - assertThat(output).containsKey("variable_output"); - Map variableOutput = (Map) output.get("variable_output"); - assertThat(variableOutput).containsKey("data"); - }) - .verifyComplete(); - - // 验证请求是否正确替换了变量 - var recordedRequest = mockWebServer.takeRequest(); - assertThat(recordedRequest.getPath()).contains("input=Hello%20World"); - assertThat(recordedRequest.getPath()).contains("key=test_value"); - assertThat(recordedRequest.getHeader("X-Custom-Header")).isEqualTo("test_value"); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_ErrorHandling() throws Exception { - // 测试错误处理 - mockWebServer.enqueue(new MockResponse().setResponseCode(500).setBody("Internal Server Error")); - - McpNode mcpNode = McpNode.builder() - .url(mockWebServer.url("/error").toString()) - .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.SSE) - .streamMode(McpNode.StreamMode.DISTRIBUTE) - .outputKey("error_output") - .readTimeout(Duration.ofSeconds(2)) - .allowInternalAddress(true) - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("error_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result) - .assertNext(output -> { - assertThat(output).containsKey("error_output"); - Map errorOutput = (Map) output.get("error_output"); - assertThat(errorOutput).containsKey("error"); - assertThat(errorOutput.get("streaming")).isEqualTo(false); - String errorMessage = errorOutput.get("error").toString(); - assertThat(errorMessage).satisfiesAnyOf( - msg -> assertThat(msg).containsIgnoringCase("500"), - msg -> assertThat(msg).containsIgnoringCase("HTTP"), - msg -> assertThat(msg).containsIgnoringCase("Internal Server Error") - ); - }) - .verifyComplete(); - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testMcpNodeBuilderConvenienceMethods() { - // 测试便捷方法 - McpNode node1 = McpNode.builder() - .url("http://example.com/stream") - .enableHttpStream() - .build(); - - // 验证默认配置 - assertThat(node1).isNotNull(); - - McpNode node2 = McpNode.builder() - .url("http://example.com/chat") - .enableHttpStream(HttpMethod.POST, McpNode.StreamFormat.JSON_LINES) - .build(); - - assertThat(node2).isNotNull(); - } - - @Test - @Timeout(value = 10, unit = TimeUnit.SECONDS) - void testMcpNodeBuilderValidation() { - // 测试构建器验证 - try { - McpNode.builder().build(); - assertThat(false).as("Should throw IllegalArgumentException for missing URL").isTrue(); - } catch (IllegalArgumentException e) { - assertThat(e.getMessage()).contains("URL cannot be null or empty"); - } - - try { - McpNode.builder() - .url("http://example.com") - .processMode(McpNode.McpProcessMode.MCP_SYNC) - .build(); - assertThat(false).as("Should throw IllegalArgumentException for missing tool in MCP_SYNC mode").isTrue(); - } catch (IllegalArgumentException e) { - assertThat(e.getMessage()).contains("Tool name is required for MCP_SYNC mode"); - } - } - - @Test - @Timeout(value = 15, unit = TimeUnit.SECONDS) - void testMcpNodeHttpStreamMode_SecurityValidation() throws Exception { - // 测试安全验证 - 拒绝内网地址 - McpNode mcpNode = McpNode.builder() - .url("http://192.168.1.1/test") - .enableHttpStream(HttpMethod.GET, McpNode.StreamFormat.JSON_LINES) - .allowInternalAddress(false) // 禁止内网访问 - .webClient(WebClient.create()) - .build(); - - CompletableFuture> future = mcpNode.apply(testState); - Map asyncResult = future.get(10, TimeUnit.SECONDS); - AsyncGenerator> generator = (AsyncGenerator>) asyncResult.get("stream_output"); - Flux> result = Flux.fromStream(generator.stream()); - - StepVerifier.create(result.timeout(Duration.ofSeconds(5))) - .assertNext(output -> { - assertThat(output).containsKey("error"); - assertThat(output.get("error").toString()).contains("Internal network access not allowed"); - }) - .verifyComplete(); - } - -} diff --git a/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNodeTest.java b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNodeTest.java new file mode 100644 index 0000000000..fb2c0d6235 --- /dev/null +++ b/spring-ai-alibaba-graph-core/src/test/java/com/alibaba/cloud/ai/graph/node/StreamableMcpNodeTest.java @@ -0,0 +1,233 @@ +/* + * Copyright 2024-2025 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.alibaba.cloud.ai.graph.node; + +import com.alibaba.cloud.ai.graph.OverAllState; +import okhttp3.mockwebserver.MockResponse; +import okhttp3.mockwebserver.MockWebServer; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +import java.util.List; +import java.util.Map; +import java.util.concurrent.CompletableFuture; + +import static org.junit.jupiter.api.Assertions.*; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.Mockito.when; + +class StreamableMcpNodeTest { + + @Mock + private McpNode mockMcpNode; + + private MockWebServer mockServer; + private AutoCloseable mocks; + + @BeforeEach + void setUp() throws Exception { + mocks = MockitoAnnotations.openMocks(this); + mockServer = new MockWebServer(); + mockServer.start(); + } + + @AfterEach + void tearDown() throws Exception { + mockServer.shutdown(); + mocks.close(); + } + + @Test + void testBuilderValidation() { + assertThrows(IllegalArgumentException.class, () -> { + StreamableMcpNode.builder().build(); + }); + } + + @Test + void testBuilderWithAllOptions() { + StreamableMcpNode node = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .streamUrl("http://localhost:8080/stream") + .format(StreamableMcpNode.StreamFormat.JSON_LINES) + .build(); + + assertNotNull(node); + } + + @Test + void testStreamFormatEnum() { + assertEquals("text/event-stream", StreamableMcpNode.StreamFormat.SSE.getContentType()); + assertEquals("application/x-ndjson", StreamableMcpNode.StreamFormat.JSON_LINES.getContentType()); + assertEquals("text/plain", StreamableMcpNode.StreamFormat.TEXT_PLAIN.getContentType()); + } + + @Test + void testApplyWithoutStreamUrl() throws Exception { + // Mock MCP结果 + Map mcpResult = Map.of( + "messages", List.of("test message"), + "result", "success" + ); + when(mockMcpNode.apply(any(OverAllState.class))).thenReturn(mcpResult); + + StreamableMcpNode node = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .build(); + + OverAllState state = new OverAllState(); + CompletableFuture> result = node.apply(state); + + Map response = result.get(); + assertEquals("success", response.get("result")); + assertEquals(List.of("test message"), response.get("messages")); + assertFalse(response.containsKey("stream_response")); + } + + @Test + void testApplyWithStreamUrlSuccess() throws Exception { + // Mock MCP结果 + Map mcpResult = Map.of("mcp_result", "success"); + when(mockMcpNode.apply(any(OverAllState.class))).thenReturn(mcpResult); + + // Mock HTTP响应 + mockServer.enqueue(new MockResponse() + .setBody("stream data") + .setHeader("Content-Type", "text/plain")); + + String streamUrl = mockServer.url("/stream").toString(); + StreamableMcpNode node = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .streamUrl(streamUrl) + .format(StreamableMcpNode.StreamFormat.TEXT_PLAIN) + .build(); + + OverAllState state = new OverAllState(); + CompletableFuture> result = node.apply(state); + + Map response = result.get(); + assertEquals("success", response.get("mcp_result")); + assertEquals("stream data", response.get("stream_response")); + } + + @Test + void testApplyWithStreamUrlHttpError() throws Exception { + // Mock MCP结果 + Map mcpResult = Map.of("mcp_result", "success"); + when(mockMcpNode.apply(any(OverAllState.class))).thenReturn(mcpResult); + + // Mock HTTP错误响应 + mockServer.enqueue(new MockResponse().setResponseCode(500)); + + String streamUrl = mockServer.url("/stream").toString(); + StreamableMcpNode node = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .streamUrl(streamUrl) + .build(); + + OverAllState state = new OverAllState(); + CompletableFuture> result = node.apply(state); + + Map response = result.get(); + assertTrue(response.containsKey("error")); + assertTrue(response.get("error").toString().contains("HTTP 500")); + } + + @Test + void testApplyWithMcpNodeException() throws Exception { + // Mock MCP异常 + when(mockMcpNode.apply(any(OverAllState.class))) + .thenThrow(new RuntimeException("MCP error")); + + StreamableMcpNode node = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .build(); + + OverAllState state = new OverAllState(); + CompletableFuture> result = node.apply(state); + + Map response = result.get(); + assertTrue(response.containsKey("error")); + assertTrue(response.get("error").toString().contains("MCP error")); + } + + @Test + void testApplyWithDifferentStreamFormats() throws Exception { + // Mock MCP结果 + Map mcpResult = Map.of("data", "test"); + when(mockMcpNode.apply(any(OverAllState.class))).thenReturn(mcpResult); + + // 测试SSE格式 + mockServer.enqueue(new MockResponse() + .setBody("data: sse content") + .setHeader("Content-Type", "text/event-stream")); + + String streamUrl = mockServer.url("/sse").toString(); + StreamableMcpNode sseNode = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .streamUrl(streamUrl) + .format(StreamableMcpNode.StreamFormat.SSE) + .build(); + + OverAllState state = new OverAllState(); + CompletableFuture> result = sseNode.apply(state); + + Map response = result.get(); + assertEquals("test", response.get("data")); + assertEquals("data: sse content", response.get("stream_response")); + } + + @Test + void testBuilderWithInvalidStreamUrl() { + assertThrows(IllegalArgumentException.class, () -> { + StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .streamUrl("invalid-url") + .build(); + }); + } + + @Test + void testApplyWithValidStreamUrl() throws Exception { + // Mock MCP结果 + Map mcpResult = Map.of("result", "ok"); + when(mockMcpNode.apply(any(OverAllState.class))).thenReturn(mcpResult); + + // Mock HTTP响应 + mockServer.enqueue(new MockResponse() + .setBody("valid response") + .setHeader("Content-Type", "text/plain")); + + String streamUrl = mockServer.url("/valid").toString(); + StreamableMcpNode node = StreamableMcpNode.builder() + .mcpNode(mockMcpNode) + .streamUrl(streamUrl) + .build(); + + OverAllState state = new OverAllState(); + CompletableFuture> result = node.apply(state); + + Map response = result.get(); + assertEquals("ok", response.get("result")); + assertEquals("valid response", response.get("stream_response")); + } + + +} From 85a234d248179e433846b65cd5dc96d235c54826 Mon Sep 17 00:00:00 2001 From: mengnankkkk Date: Wed, 24 Sep 2025 00:04:42 +0800 Subject: [PATCH 11/11] fix: ci bug --- spring-ai-alibaba-graph-core/pom.xml | 3 --- .../java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java | 2 -- 2 files changed, 5 deletions(-) diff --git a/spring-ai-alibaba-graph-core/pom.xml b/spring-ai-alibaba-graph-core/pom.xml index 9d0536c5f8..40c2066be9 100644 --- a/spring-ai-alibaba-graph-core/pom.xml +++ b/spring-ai-alibaba-graph-core/pom.xml @@ -188,14 +188,11 @@ test - - org.redisson diff --git a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java index 76c2b1fab1..755e9f3c25 100644 --- a/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java +++ b/spring-ai-alibaba-graph-core/src/main/java/com/alibaba/cloud/ai/graph/executor/NodeExecutor.java @@ -404,6 +404,4 @@ private Flux> handleEmbeddedGenerator(GraphRunnerConte })); } - - }