adai/MemoryBear
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #985 from wanxunyang/develop-wxy

Browse Source 
feat: enhance workflow debugging, logging and auth middleware
This commit is contained in:
山程漫悟
2026-04-24 10:17:32 +08:00
committed by GitHub
parent c818855bab fb23c34475
commit 9fdb952396
14 changed files with 358 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
api/app/core/api_key_auth.py
View File

@@ -70,6 +70,8 @@ def require_api_key(
})
raise BusinessException("API Key 无效或已过期", BizCode.API_KEY_INVALID)
ApiKeyAuthService.check_app_published(db, api_key_obj)
if scopes:
missing_scopes = []
for scope in scopes:

1
api/app/core/error_codes.py
View File

@@ -66,6 +66,7 @@ class BizCode(IntEnum):
PERMISSION_DENIED = 6010
INVALID_CONVERSATION = 6011
CONFIG_MISSING = 6012
APP_NOT_PUBLISHED = 6013
# 模型（7xxx）
MODEL_CONFIG_INVALID = 7001

20
api/app/core/workflow/adapters/dify/converter.py
View File

@@ -156,8 +156,13 @@ class DifyConverter(BaseConverter):
def replacer(match: re.Match) -> str:
raw_name = match.group(1)
new_name = self.process_var_selector(raw_name)
return f"{{{{{new_name}}}}}"
try:
new_name = self.process_var_selector(raw_name)
if not new_name:
return match.group(0)
return f"{{{{{new_name}}}}}"
except Exception:
return match.group(0)
return pattern.sub(replacer, content)
@@ -633,8 +638,15 @@ class DifyConverter(BaseConverter):
] = self.trans_variable_format(content["value"])
else:
if node_data["body"]["data"]:
body_content = (node_data["body"]["data"][0].get("value") or
self._process_list_variable_literal(node_data["body"]["data"][0].get("file")))
data_entry = node_data["body"]["data"][0]
body_content = data_entry.get("value")
if not body_content and data_entry.get("file"):
body_content = self._process_list_variable_literal(data_entry.get("file"))
if not body_content:
body_content = ""
elif isinstance(body_content, str):
# Convert session variable format for JSON body
body_content = self.trans_variable_format(body_content)
else:
body_content = ""

4
api/app/core/workflow/engine/event_stream_handler.py
View File

@@ -167,8 +167,9 @@ class EventStreamHandler:
"node_id": node_id,
"status": "failed",
"input": data.get("input_data"),
"elapsed_time": data.get("elapsed_time"),
"output": None,
"process": data.get("process_data"),
"elapsed_time": data.get("elapsed_time"),
"error": data.get("error")
}
}
@@ -266,6 +267,7 @@ class EventStreamHandler:
).timestamp() * 1000),
"input": result.get("node_outputs", {}).get(node_name, {}).get("input"),
"output": result.get("node_outputs", {}).get(node_name, {}).get("output"),
"process": result.get("node_outputs", {}).get(node_name, {}).get("process"),
"elapsed_time": result.get("node_outputs", {}).get(node_name, {}).get("elapsed_time"),
"token_usage": result.get("node_outputs", {}).get(node_name, {}).get("token_usage")
}

12
api/app/core/workflow/nodes/http_request/config.py
View File

@@ -132,6 +132,11 @@ class HttpErrorDefaultTemplate(BaseModel):
description="Default HTTP headers returned on error",
)
files: list = Field(
default_factory=list,
description="Default files list returned on error",
)
output: str = Field(
default="SUCCESS",
description="HTTP response body",
@@ -246,6 +251,13 @@ class HttpRequestNodeConfig(BaseNodeConfig):
}
class HttpRequestDataProcessing(BaseModel):
request: str = Field(
default="",
description="Raw HTTP request format for debugging",
)
class HttpRequestNodeOutput(BaseModel):
body: str = Field(
...,

156
api/app/core/workflow/nodes/http_request/node.py
View File

@@ -160,6 +160,7 @@ class HttpRequestNode(BaseNode):
def __init__(self, node_config: dict[str, Any], workflow_config: dict[str, Any], down_stream_nodes: list[str]):
super().__init__(node_config, workflow_config, down_stream_nodes)
self.typed_config: HttpRequestNodeConfig | None = None
self.last_request: str = ""
def _output_types(self) -> dict[str, VariableType]:
return {
@@ -170,6 +171,47 @@ class HttpRequestNode(BaseNode):
"output": VariableType.STRING
}
def _extract_output(self, business_result: Any) -> Any:
if isinstance(business_result, dict):
result = {k: v for k, v in business_result.items() if k != "request"}
return result
return business_result
def _extract_extra_fields(self, business_result: Any) -> dict[str, Any]:
if isinstance(business_result, dict) and "request" in business_result:
return {
"process": {
"request": business_result.get("request", "")
}
}
return {}
def _wrap_error(
self,
error_message: str,
elapsed_time: float,
state: WorkflowState,
variable_pool: VariablePool
) -> dict[str, Any]:
input_data = self._extract_input(state, variable_pool)
node_output = {
"node_id": self.node_id,
"node_type": self.node_type,
"node_name": self.node_name,
"status": "failed",
"input": input_data,
"output": None,
"process": {"request": self.last_request} if self.last_request else None,
"elapsed_time": elapsed_time,
"token_usage": None,
"error": error_message
}
return {
"node_outputs": {self.node_id: node_output},
"error": error_message,
"error_node": self.node_id
}
def _build_timeout(self) -> Timeout:
"""
Build httpx Timeout configuration.
@@ -255,9 +297,13 @@ class HttpRequestNode(BaseNode):
case HttpContentType.NONE:
return {}
case HttpContentType.JSON:
content["json"] = json.loads(self._render_template(
rendered_body = self._render_template(
self.typed_config.body.data, variable_pool
))
).strip()
if not rendered_body:
content["json"] = {}
else:
content["json"] = json.loads(rendered_body)
case HttpContentType.FROM_DATA:
data = {}
files = []
@@ -325,6 +371,62 @@ class HttpRequestNode(BaseNode):
case _:
raise RuntimeError(f"HttpRequest method not supported: {self.typed_config.method}")
def _generate_raw_request(
self,
variable_pool: VariablePool,
url: str,
headers: dict[str, str],
params: dict[str, str],
content: dict[str, Any]
) -> str:
"""
Generate raw HTTP request format for debugging.
Args:
variable_pool: Variable Pool
url: Rendered URL
headers: Request headers
params: Query parameters
content: Request body content
Returns:
Raw HTTP request string
"""
method = self.typed_config.method.value
if params:
param_str = "&".join([f"{k}={v}" for k, v in params.items()])
full_url = f"{url}?{param_str}" if "?" not in url else f"{url}&{param_str}"
else:
full_url = url
lines = [f"{method} {full_url} HTTP/1.1"]
for key, value in headers.items():
lines.append(f"{key}: {value}")
if "json" in content and content["json"]:
json_body = json.dumps(content["json"], ensure_ascii=False)
lines.append(f"Content-Length: {len(json_body)}")
lines.append("")
lines.append(json_body)
elif "data" in content and "files" not in content:
if isinstance(content["data"], dict):
body_str = "&".join([f"{k}={v}" for k, v in content["data"].items()])
lines.append(f"Content-Length: {len(body_str)}")
lines.append("")
lines.append(body_str)
elif "content" in content:
lines.append(f"Content-Length: {len(content['content'])}")
lines.append("")
lines.append(content["content"])
elif "files" in content:
lines.append("Content-Length: 0")
lines.append("")
lines.append("# Note: This request includes file uploads")
return "\r\n".join(lines)
async def execute(self, state: WorkflowState, variable_pool: VariablePool) -> dict | str:
"""
Execute the HTTP request node.
@@ -343,11 +445,25 @@ class HttpRequestNode(BaseNode):
- str: Branch identifier (e.g. "ERROR") when branching is enabled
"""
self.typed_config = HttpRequestNodeConfig(**self.config)
# Build request components
headers = self._build_header(variable_pool) | self._build_auth(variable_pool)
params = self._build_params(variable_pool)
content = await self._build_content(variable_pool)
url = self._render_template(self.typed_config.url, variable_pool)
logger.info(f"Node {self.node_id}: headers={headers}, params={params}, content keys={list(content.keys())}")
# Generate raw HTTP request for debugging
raw_request = self._generate_raw_request(variable_pool, url, headers, params, content)
self.last_request = raw_request
logger.info(f"Node {self.node_id}: Generated HTTP request:\n{raw_request}")
async with httpx.AsyncClient(
verify=self.typed_config.verify_ssl,
timeout=self._build_timeout(),
headers=self._build_header(variable_pool) | self._build_auth(variable_pool),
params=self._build_params(variable_pool),
headers=headers,
params=params,
follow_redirects=True
) as client:
retries = self.typed_config.retry.max_attempts
@@ -355,18 +471,21 @@ class HttpRequestNode(BaseNode):
try:
request_func = self._get_client_method(client)
resp = await request_func(
url=self._render_template(self.typed_config.url, variable_pool),
**(await self._build_content(variable_pool))
url=url,
**content
)
resp.raise_for_status()
logger.info(f"Node {self.node_id}: HTTP request succeeded")
response = HttpResponse(resp)
return HttpRequestNodeOutput(
body=response.body,
status_code=resp.status_code,
headers=resp.headers,
files=response.files
).model_dump()
return {
**HttpRequestNodeOutput(
body=response.body,
status_code=resp.status_code,
headers=resp.headers,
files=response.files
).model_dump(),
"request": raw_request
}
except (httpx.HTTPStatusError, httpx.RequestError) as e:
logger.error(f"HTTP request node exception: {e}")
retries -= 1
@@ -382,10 +501,19 @@ class HttpRequestNode(BaseNode):
logger.warning(
f"Node {self.node_id}: HTTP request failed, returning default result"
)
return self.typed_config.error_handle.default.model_dump()
error_result = self.typed_config.error_handle.default.model_dump()
error_result["request"] = raw_request
return error_result
case HttpErrorHandle.BRANCH:
logger.warning(
f"Node {self.node_id}: HTTP request failed, switching to error handling branch"
)
return {"output": "ERROR"}
return {
"output": "ERROR",
"body": "",
"status_code": 500,
"headers": {},
"files": [],
"request": raw_request
}
raise RuntimeError("http request failed")