GithubBackup/clawpanel
1
0
Fork 0
mirror of https://github.com/qingchencloud/clawpanel.git synced 2026-05-29 04:10:00 +08:00
Code Issues Packages Projects Releases Wiki Activity

feat(hermes): add tool loop guardrails form

Browse Source
This commit is contained in:
晴天
2026-05-24 07:38:42 +08:00
parent 5dd6f1be40
commit 18ca140af8
9 changed files with 688 additions and 3 deletions
Download Patch File Download Diff File Expand all files Collapse all files

71
scripts/dev-api.js
View File

@@ -3403,6 +3403,56 @@ export function mergeHermesCompressionConfig(config = {}, form = {}) {
return next
}
export function buildHermesToolLoopGuardrailsConfigValues(config = {}) {
const root = config && typeof config === 'object' && !Array.isArray(config) ? config : {}
const guardrails = root.tool_loop_guardrails && typeof root.tool_loop_guardrails === 'object' && !Array.isArray(root.tool_loop_guardrails)
? root.tool_loop_guardrails
: {}
const warnAfter = guardrails.warn_after && typeof guardrails.warn_after === 'object' && !Array.isArray(guardrails.warn_after)
? guardrails.warn_after
: {}
const hardStopAfter = guardrails.hard_stop_after && typeof guardrails.hard_stop_after === 'object' && !Array.isArray(guardrails.hard_stop_after)
? guardrails.hard_stop_after
: {}
return {
warningsEnabled: readHermesBool(guardrails.warnings_enabled, true),
hardStopEnabled: readHermesBool(guardrails.hard_stop_enabled, false),
warnExactFailure: parseHermesInteger(warnAfter.exact_failure ?? guardrails.exact_failure_warn_after, 'tool_loop_guardrails.warn_after.exact_failure', 2, 1, 100, false),
warnSameToolFailure: parseHermesInteger(warnAfter.same_tool_failure ?? guardrails.same_tool_failure_warn_after, 'tool_loop_guardrails.warn_after.same_tool_failure', 3, 1, 100, false),
warnNoProgress: parseHermesInteger(warnAfter.idempotent_no_progress ?? guardrails.no_progress_warn_after, 'tool_loop_guardrails.warn_after.idempotent_no_progress', 2, 1, 100, false),
hardStopExactFailure: parseHermesInteger(hardStopAfter.exact_failure ?? guardrails.exact_failure_block_after, 'tool_loop_guardrails.hard_stop_after.exact_failure', 5, 1, 100, false),
hardStopSameToolFailure: parseHermesInteger(hardStopAfter.same_tool_failure ?? guardrails.same_tool_failure_halt_after, 'tool_loop_guardrails.hard_stop_after.same_tool_failure', 8, 1, 100, false),
hardStopNoProgress: parseHermesInteger(hardStopAfter.idempotent_no_progress ?? guardrails.no_progress_block_after, 'tool_loop_guardrails.hard_stop_after.idempotent_no_progress', 5, 1, 100, false),
}
}
export function mergeHermesToolLoopGuardrailsConfig(config = {}, form = {}) {
const next = mergeConfigsPreservingFields({}, config && typeof config === 'object' && !Array.isArray(config) ? config : {})
const currentValues = buildHermesToolLoopGuardrailsConfigValues(next)
const guardrails = next.tool_loop_guardrails && typeof next.tool_loop_guardrails === 'object' && !Array.isArray(next.tool_loop_guardrails)
? mergeConfigsPreservingFields(next.tool_loop_guardrails, {})
: {}
const warnAfter = guardrails.warn_after && typeof guardrails.warn_after === 'object' && !Array.isArray(guardrails.warn_after)
? mergeConfigsPreservingFields(guardrails.warn_after, {})
: {}
const hardStopAfter = guardrails.hard_stop_after && typeof guardrails.hard_stop_after === 'object' && !Array.isArray(guardrails.hard_stop_after)
? mergeConfigsPreservingFields(guardrails.hard_stop_after, {})
: {}
guardrails.warnings_enabled = formHermesBool(form, 'warningsEnabled', currentValues.warningsEnabled)
guardrails.hard_stop_enabled = formHermesBool(form, 'hardStopEnabled', currentValues.hardStopEnabled)
warnAfter.exact_failure = parseHermesInteger(Object.hasOwn(form, 'warnExactFailure') ? form.warnExactFailure : currentValues.warnExactFailure, 'tool_loop_guardrails.warn_after.exact_failure', 2, 1, 100, true)
warnAfter.same_tool_failure = parseHermesInteger(Object.hasOwn(form, 'warnSameToolFailure') ? form.warnSameToolFailure : currentValues.warnSameToolFailure, 'tool_loop_guardrails.warn_after.same_tool_failure', 3, 1, 100, true)
warnAfter.idempotent_no_progress = parseHermesInteger(Object.hasOwn(form, 'warnNoProgress') ? form.warnNoProgress : currentValues.warnNoProgress, 'tool_loop_guardrails.warn_after.idempotent_no_progress', 2, 1, 100, true)
hardStopAfter.exact_failure = parseHermesInteger(Object.hasOwn(form, 'hardStopExactFailure') ? form.hardStopExactFailure : currentValues.hardStopExactFailure, 'tool_loop_guardrails.hard_stop_after.exact_failure', 5, 1, 100, true)
hardStopAfter.same_tool_failure = parseHermesInteger(Object.hasOwn(form, 'hardStopSameToolFailure') ? form.hardStopSameToolFailure : currentValues.hardStopSameToolFailure, 'tool_loop_guardrails.hard_stop_after.same_tool_failure', 8, 1, 100, true)
hardStopAfter.idempotent_no_progress = parseHermesInteger(Object.hasOwn(form, 'hardStopNoProgress') ? form.hardStopNoProgress : currentValues.hardStopNoProgress, 'tool_loop_guardrails.hard_stop_after.idempotent_no_progress', 5, 1, 100, true)
guardrails.warn_after = warnAfter
guardrails.hard_stop_after = hardStopAfter
next.tool_loop_guardrails = guardrails
return next
}
export function buildHermesSessionRuntimeConfigValues(config = {}) {
const root = config && typeof config === 'object' && !Array.isArray(config) ? config : {}
const sessionReset = root.session_reset && typeof root.session_reset === 'object' && !Array.isArray(root.session_reset)
@@ -9646,6 +9696,27 @@ const handlers = {
}
},
hermes_tool_loop_guardrails_config_read() {
const { configPath, exists, config } = readHermesConfigYamlObject()
return {
exists,
configPath,
values: buildHermesToolLoopGuardrailsConfigValues(config),
}
},
hermes_tool_loop_guardrails_config_save({ form } = {}) {
const { configPath, config } = readHermesConfigYamlObject()
const next = mergeHermesToolLoopGuardrailsConfig(config, form || {})
const backup = writeHermesConfigYamlObject(configPath, next)
return {
ok: true,
configPath,
backup,
values: buildHermesToolLoopGuardrailsConfigValues(next),
}
},
// P1-3 lazy_deps: Web 模式下不能调 venv python，但仍提供 feature 列表 + 提示用户走桌面端装
hermes_lazy_deps_features() {
const features = [

310
src-tauri/src/commands/hermes.rs
View File

@@ -3163,6 +3163,164 @@ fn merge_hermes_compression_config(
Ok(())
}
fn build_hermes_tool_loop_guardrails_config_values(config: &serde_yaml::Value) -> Value {
let root = config.as_mapping();
let guardrails = root.and_then(|map| yaml_get_mapping(map, "tool_loop_guardrails"));
let warn_after = guardrails.and_then(|map| yaml_get_mapping(map, "warn_after"));
let hard_stop_after = guardrails.and_then(|map| yaml_get_mapping(map, "hard_stop_after"));
let warnings_enabled = guardrails
.and_then(|map| yaml_bool_field(map, "warnings_enabled"))
.unwrap_or(true);
let hard_stop_enabled = guardrails
.and_then(|map| yaml_bool_field(map, "hard_stop_enabled"))
.unwrap_or(false);
let warn_exact_failure = warn_after
.and_then(|map| yaml_i64_field(map, "exact_failure"))
.or_else(|| guardrails.and_then(|map| yaml_i64_field(map, "exact_failure_warn_after")));
let warn_same_tool_failure = warn_after
.and_then(|map| yaml_i64_field(map, "same_tool_failure"))
.or_else(|| guardrails.and_then(|map| yaml_i64_field(map, "same_tool_failure_warn_after")));
let warn_no_progress = warn_after
.and_then(|map| yaml_i64_field(map, "idempotent_no_progress"))
.or_else(|| guardrails.and_then(|map| yaml_i64_field(map, "no_progress_warn_after")));
let hard_stop_exact_failure = hard_stop_after
.and_then(|map| yaml_i64_field(map, "exact_failure"))
.or_else(|| guardrails.and_then(|map| yaml_i64_field(map, "exact_failure_block_after")));
let hard_stop_same_tool_failure = hard_stop_after
.and_then(|map| yaml_i64_field(map, "same_tool_failure"))
.or_else(|| guardrails.and_then(|map| yaml_i64_field(map, "same_tool_failure_halt_after")));
let hard_stop_no_progress = hard_stop_after
.and_then(|map| yaml_i64_field(map, "idempotent_no_progress"))
.or_else(|| guardrails.and_then(|map| yaml_i64_field(map, "no_progress_block_after")));
serde_json::json!({
"warningsEnabled": warnings_enabled,
"hardStopEnabled": hard_stop_enabled,
"warnExactFailure": bounded_hermes_i64(warn_exact_failure, 2, 1, 100),
"warnSameToolFailure": bounded_hermes_i64(warn_same_tool_failure, 3, 1, 100),
"warnNoProgress": bounded_hermes_i64(warn_no_progress, 2, 1, 100),
"hardStopExactFailure": bounded_hermes_i64(hard_stop_exact_failure, 5, 1, 100),
"hardStopSameToolFailure": bounded_hermes_i64(hard_stop_same_tool_failure, 8, 1, 100),
"hardStopNoProgress": bounded_hermes_i64(hard_stop_no_progress, 5, 1, 100),
})
}
fn merge_hermes_tool_loop_guardrails_config(
config: &mut serde_yaml::Value,
form: &Value,
) -> Result<(), String> {
let current = build_hermes_tool_loop_guardrails_config_values(config);
let warnings_enabled = form_bool(form, "warningsEnabled")
.unwrap_or_else(|| current["warningsEnabled"].as_bool().unwrap_or(true));
let hard_stop_enabled = form_bool(form, "hardStopEnabled")
.unwrap_or_else(|| current["hardStopEnabled"].as_bool().unwrap_or(false));
let warn_exact_failure = validate_hermes_i64(
if form.get("warnExactFailure").is_some() {
form_i64(form, "warnExactFailure")
} else {
Some(current["warnExactFailure"].as_i64().unwrap_or(2))
},
"tool_loop_guardrails.warn_after.exact_failure",
2,
1,
100,
)?;
let warn_same_tool_failure = validate_hermes_i64(
if form.get("warnSameToolFailure").is_some() {
form_i64(form, "warnSameToolFailure")
} else {
Some(current["warnSameToolFailure"].as_i64().unwrap_or(3))
},
"tool_loop_guardrails.warn_after.same_tool_failure",
3,
1,
100,
)?;
let warn_no_progress = validate_hermes_i64(
if form.get("warnNoProgress").is_some() {
form_i64(form, "warnNoProgress")
} else {
Some(current["warnNoProgress"].as_i64().unwrap_or(2))
},
"tool_loop_guardrails.warn_after.idempotent_no_progress",
2,
1,
100,
)?;
let hard_stop_exact_failure = validate_hermes_i64(
if form.get("hardStopExactFailure").is_some() {
form_i64(form, "hardStopExactFailure")
} else {
Some(current["hardStopExactFailure"].as_i64().unwrap_or(5))
},
"tool_loop_guardrails.hard_stop_after.exact_failure",
5,
1,
100,
)?;
let hard_stop_same_tool_failure = validate_hermes_i64(
if form.get("hardStopSameToolFailure").is_some() {
form_i64(form, "hardStopSameToolFailure")
} else {
Some(current["hardStopSameToolFailure"].as_i64().unwrap_or(8))
},
"tool_loop_guardrails.hard_stop_after.same_tool_failure",
8,
1,
100,
)?;
let hard_stop_no_progress = validate_hermes_i64(
if form.get("hardStopNoProgress").is_some() {
form_i64(form, "hardStopNoProgress")
} else {
Some(current["hardStopNoProgress"].as_i64().unwrap_or(5))
},
"tool_loop_guardrails.hard_stop_after.idempotent_no_progress",
5,
1,
100,
)?;
let root = ensure_yaml_object(config)?;
let guardrails = yaml_child_object(root, "tool_loop_guardrails")?;
guardrails.insert(
yaml_key("warnings_enabled"),
serde_yaml::Value::Bool(warnings_enabled),
);
guardrails.insert(
yaml_key("hard_stop_enabled"),
serde_yaml::Value::Bool(hard_stop_enabled),
);
let warn_after = yaml_child_object(guardrails, "warn_after")?;
warn_after.insert(
yaml_key("exact_failure"),
serde_yaml::Value::Number(warn_exact_failure.into()),
);
warn_after.insert(
yaml_key("same_tool_failure"),
serde_yaml::Value::Number(warn_same_tool_failure.into()),
);
warn_after.insert(
yaml_key("idempotent_no_progress"),
serde_yaml::Value::Number(warn_no_progress.into()),
);
let hard_stop_after = yaml_child_object(guardrails, "hard_stop_after")?;
hard_stop_after.insert(
yaml_key("exact_failure"),
serde_yaml::Value::Number(hard_stop_exact_failure.into()),
);
hard_stop_after.insert(
yaml_key("same_tool_failure"),
serde_yaml::Value::Number(hard_stop_same_tool_failure.into()),
);
hard_stop_after.insert(
yaml_key("idempotent_no_progress"),
serde_yaml::Value::Number(hard_stop_no_progress.into()),
);
Ok(())
}
fn build_hermes_session_runtime_config_values(config: &serde_yaml::Value) -> Value {
let root = config.as_mapping();
let session_reset = root.and_then(|map| yaml_get_mapping(map, "session_reset"));
@@ -3997,6 +4155,30 @@ pub fn hermes_compression_config_save(form: Value) -> Result<Value, String> {
}))
}
#[tauri::command]
pub fn hermes_tool_loop_guardrails_config_read() -> Result<Value, String> {
let (config_path, exists, config) = read_hermes_channel_yaml_config()?;
ensure_yaml_object(&mut config.clone())?;
Ok(serde_json::json!({
"exists": exists,
"configPath": config_path.to_string_lossy(),
"values": build_hermes_tool_loop_guardrails_config_values(&config),
}))
}
#[tauri::command]
pub fn hermes_tool_loop_guardrails_config_save(form: Value) -> Result<Value, String> {
let (config_path, _exists, mut config) = read_hermes_channel_yaml_config()?;
merge_hermes_tool_loop_guardrails_config(&mut config, &form)?;
let backup = write_hermes_yaml_config(&config_path, &config)?;
Ok(serde_json::json!({
"ok": true,
"configPath": config_path.to_string_lossy(),
"backup": backup,
"values": build_hermes_tool_loop_guardrails_config_values(&config),
}))
}
// ---------------------------------------------------------------------------
// hermes_read_config — 读取 Hermes config.yaml + .env
// ---------------------------------------------------------------------------
@@ -9055,6 +9237,134 @@ streaming:
}
}
#[cfg(test)]
mod hermes_tool_loop_guardrails_config_tests {
use super::{
build_hermes_tool_loop_guardrails_config_values, merge_hermes_tool_loop_guardrails_config,
};
use serde_json::json;
#[test]
fn tool_loop_guardrails_values_have_upstream_defaults() {
let config: serde_yaml::Value = serde_yaml::from_str("{}").unwrap();
let values = build_hermes_tool_loop_guardrails_config_values(&config);
assert_eq!(values["warningsEnabled"], true);
assert_eq!(values["hardStopEnabled"], false);
assert_eq!(values["warnExactFailure"], 2);
assert_eq!(values["warnSameToolFailure"], 3);
assert_eq!(values["warnNoProgress"], 2);
assert_eq!(values["hardStopExactFailure"], 5);
assert_eq!(values["hardStopSameToolFailure"], 8);
assert_eq!(values["hardStopNoProgress"], 5);
}
#[test]
fn merge_tool_loop_guardrails_config_preserves_unrelated_yaml() {
let mut config: serde_yaml::Value = serde_yaml::from_str(
r#"
model:
provider: anthropic
tool_loop_guardrails:
warnings_enabled: true
custom_flag: keep-me
warn_after:
exact_failure: 2
custom_warn: 99
streaming:
enabled: true
"#,
)
.unwrap();
merge_hermes_tool_loop_guardrails_config(
&mut config,
&json!({
"warningsEnabled": false,
"hardStopEnabled": true,
"warnExactFailure": "3",
"warnSameToolFailure": "4",
"warnNoProgress": "5",
"hardStopExactFailure": "6",
"hardStopSameToolFailure": "7",
"hardStopNoProgress": "8",
}),
)
.unwrap();
assert_eq!(config["model"]["provider"].as_str(), Some("anthropic"));
assert_eq!(config["streaming"]["enabled"].as_bool(), Some(true));
assert_eq!(
config["tool_loop_guardrails"]["warnings_enabled"].as_bool(),
Some(false)
);
assert_eq!(
config["tool_loop_guardrails"]["hard_stop_enabled"].as_bool(),
Some(true)
);
assert_eq!(
config["tool_loop_guardrails"]["custom_flag"].as_str(),
Some("keep-me")
);
assert_eq!(
config["tool_loop_guardrails"]["warn_after"]["exact_failure"].as_i64(),
Some(3)
);
assert_eq!(
config["tool_loop_guardrails"]["warn_after"]["same_tool_failure"].as_i64(),
Some(4)
);
assert_eq!(
config["tool_loop_guardrails"]["warn_after"]["idempotent_no_progress"].as_i64(),
Some(5)
);
assert_eq!(
config["tool_loop_guardrails"]["warn_after"]["custom_warn"].as_i64(),
Some(99)
);
assert_eq!(
config["tool_loop_guardrails"]["hard_stop_after"]["exact_failure"].as_i64(),
Some(6)
);
assert_eq!(
config["tool_loop_guardrails"]["hard_stop_after"]["same_tool_failure"].as_i64(),
Some(7)
);
assert_eq!(
config["tool_loop_guardrails"]["hard_stop_after"]["idempotent_no_progress"].as_i64(),
Some(8)
);
}
#[test]
fn merge_tool_loop_guardrails_config_rejects_invalid_values() {
let mut config: serde_yaml::Value = serde_yaml::from_str("{}").unwrap();
let err = merge_hermes_tool_loop_guardrails_config(
&mut config,
&json!({ "warnExactFailure": 0 }),
)
.unwrap_err();
assert!(err.contains("tool_loop_guardrails.warn_after.exact_failure"));
let err = merge_hermes_tool_loop_guardrails_config(
&mut config,
&json!({ "warnSameToolFailure": 101 }),
)
.unwrap_err();
assert!(err.contains("tool_loop_guardrails.warn_after.same_tool_failure"));
let err = merge_hermes_tool_loop_guardrails_config(
&mut config,
&json!({ "hardStopExactFailure": 0 }),
)
.unwrap_err();
assert!(err.contains("tool_loop_guardrails.hard_stop_after.exact_failure"));
let err = merge_hermes_tool_loop_guardrails_config(
&mut config,
&json!({ "hardStopNoProgress": 101 }),
)
.unwrap_err();
assert!(err.contains("tool_loop_guardrails.hard_stop_after.idempotent_no_progress"));
}
}
#[cfg(test)]
mod hermes_channel_tests {
use super::{

2
src-tauri/src/lib.rs
View File

@@ -261,6 +261,8 @@ pub fn run() {
hermes::hermes_session_runtime_config_save,
hermes::hermes_compression_config_read,
hermes::hermes_compression_config_save,
hermes::hermes_tool_loop_guardrails_config_read,
hermes::hermes_tool_loop_guardrails_config_save,
hermes::hermes_lazy_deps_features,
hermes::hermes_lazy_deps_status,
hermes::hermes_lazy_deps_ensure,

135
src/engines/hermes/pages/config.js
View File

@@ -23,6 +23,17 @@ const COMPRESSION_DEFAULTS = {
abortOnSummaryFailure: false,
}
const TOOL_GUARDRAILS_DEFAULTS = {
warningsEnabled: true,
hardStopEnabled: false,
warnExactFailure: 2,
warnSameToolFailure: 3,
warnNoProgress: 2,
hardStopExactFailure: 5,
hardStopSameToolFailure: 8,
hardStopNoProgress: 5,
}
const SESSION_RESET_MODES = ['both', 'idle', 'daily', 'none']
export function render() {
@@ -32,15 +43,19 @@ export function render() {
let yaml = ''
let runtimeValues = { ...SESSION_RUNTIME_DEFAULTS }
let compressionValues = { ...COMPRESSION_DEFAULTS }
let toolGuardrailsValues = { ...TOOL_GUARDRAILS_DEFAULTS }
let loading = true
let runtimeLoading = true
let compressionLoading = true
let toolGuardrailsLoading = true
let saving = false
let runtimeSaving = false
let compressionSaving = false
let toolGuardrailsSaving = false
let error = null
let runtimeError = null
let compressionError = null
let toolGuardrailsError = null
function esc(value) {
return String(value || '')
@@ -51,7 +66,7 @@ export function render() {
}
function isBusy() {
return loading || runtimeLoading || compressionLoading || saving || runtimeSaving || compressionSaving
return loading || runtimeLoading || compressionLoading || toolGuardrailsLoading || saving || runtimeSaving || compressionSaving || toolGuardrailsSaving
}
function option(labelKey, value, selected) {
@@ -68,7 +83,7 @@ export function render() {
}
function renderRuntimePanel() {
const disabled = loading || saving || runtimeLoading || runtimeSaving || compressionSaving
const disabled = loading || saving || runtimeLoading || runtimeSaving || compressionSaving || toolGuardrailsSaving
return `
<div class="hm-panel hm-config-runtime-panel">
<div class="hm-panel-header">
@@ -116,7 +131,7 @@ export function render() {
}
function renderCompressionPanel() {
const disabled = loading || saving || compressionLoading || compressionSaving || runtimeSaving
const disabled = loading || saving || compressionLoading || compressionSaving || runtimeSaving || toolGuardrailsSaving
return `
<div class="hm-panel hm-config-runtime-panel hm-config-compression-panel">
<div class="hm-panel-header">
@@ -165,6 +180,68 @@ export function render() {
`
}
function renderToolGuardrailsPanel() {
const disabled = loading || saving || toolGuardrailsLoading || toolGuardrailsSaving || runtimeSaving || compressionSaving
return `
<div class="hm-panel hm-config-runtime-panel hm-config-guardrails-panel">
<div class="hm-panel-header">
<div>
<div class="hm-panel-title">${t('engine.hermesToolGuardrailsTitle')}</div>
<div class="hm-channel-panel-desc">${t('engine.hermesToolGuardrailsDesc')}</div>
</div>
<div class="hm-panel-actions">
<span class="hm-muted">${toolGuardrailsSaving ? t('engine.hermesConfigStatusSaving') : toolGuardrailsLoading ? t('engine.hermesConfigStatusLoading') : t('engine.hermesToolGuardrailsStatusReady')}</span>
<button class="hm-btn hm-btn--cta hm-btn--sm" id="hm-tool-guardrails-save" ${disabled ? 'disabled' : ''}>${t('engine.hermesToolGuardrailsSave')}</button>
</div>
</div>
<div class="hm-panel-body">
${renderError(toolGuardrailsError)}
<div class="hm-config-check-grid">
<label class="hm-channel-check">
<input id="hm-tool-guardrails-warnings-enabled" type="checkbox" ${toolGuardrailsValues.warningsEnabled ? 'checked' : ''} ${disabled ? 'disabled' : ''}>
<span>${t('engine.hermesToolGuardrailsWarningsEnabled')}</span>
</label>
<label class="hm-channel-check">
<input id="hm-tool-guardrails-hard-stop-enabled" type="checkbox" ${toolGuardrailsValues.hardStopEnabled ? 'checked' : ''} ${disabled ? 'disabled' : ''}>
<span>${t('engine.hermesToolGuardrailsHardStopEnabled')}</span>
</label>
</div>
<div class="hm-config-subtitle">${t('engine.hermesToolGuardrailsWarnAfterTitle')}</div>
<div class="hm-config-runtime-grid hm-config-guardrails-grid">
<label class="hm-field">
<span class="hm-field-label">${t('engine.hermesToolGuardrailsWarnExactFailure')}</span>
<input id="hm-tool-guardrails-warn-exact-failure" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(toolGuardrailsValues.warnExactFailure)}" ${disabled ? 'disabled' : ''}>
</label>
<label class="hm-field">
<span class="hm-field-label">${t('engine.hermesToolGuardrailsWarnSameToolFailure')}</span>
<input id="hm-tool-guardrails-warn-same-tool-failure" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(toolGuardrailsValues.warnSameToolFailure)}" ${disabled ? 'disabled' : ''}>
</label>
<label class="hm-field">
<span class="hm-field-label">${t('engine.hermesToolGuardrailsWarnNoProgress')}</span>
<input id="hm-tool-guardrails-warn-no-progress" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(toolGuardrailsValues.warnNoProgress)}" ${disabled ? 'disabled' : ''}>
</label>
</div>
<div class="hm-config-subtitle">${t('engine.hermesToolGuardrailsHardStopAfterTitle')}</div>
<div class="hm-config-runtime-grid hm-config-guardrails-grid">
<label class="hm-field">
<span class="hm-field-label">${t('engine.hermesToolGuardrailsHardStopExactFailure')}</span>
<input id="hm-tool-guardrails-hard-stop-exact-failure" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(toolGuardrailsValues.hardStopExactFailure)}" ${disabled ? 'disabled' : ''}>
</label>
<label class="hm-field">
<span class="hm-field-label">${t('engine.hermesToolGuardrailsHardStopSameToolFailure')}</span>
<input id="hm-tool-guardrails-hard-stop-same-tool-failure" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(toolGuardrailsValues.hardStopSameToolFailure)}" ${disabled ? 'disabled' : ''}>
</label>
<label class="hm-field">
<span class="hm-field-label">${t('engine.hermesToolGuardrailsHardStopNoProgress')}</span>
<input id="hm-tool-guardrails-hard-stop-no-progress" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(toolGuardrailsValues.hardStopNoProgress)}" ${disabled ? 'disabled' : ''}>
</label>
</div>
<div class="hm-channel-footnote">${t('engine.hermesToolGuardrailsFootnote')}</div>
</div>
</div>
`
}
function draw() {
el.innerHTML = `
<div class="hm-hero">
@@ -181,6 +258,7 @@ export function render() {
${renderRuntimePanel()}
${renderCompressionPanel()}
${renderToolGuardrailsPanel()}
<div class="hm-panel">
<div class="hm-panel-header">
@@ -202,6 +280,7 @@ export function render() {
el.querySelector('#hm-config-save')?.addEventListener('click', save)
el.querySelector('#hm-runtime-save')?.addEventListener('click', saveRuntime)
el.querySelector('#hm-compression-save')?.addEventListener('click', saveCompression)
el.querySelector('#hm-tool-guardrails-save')?.addEventListener('click', saveToolGuardrails)
}
async function loadRaw() {
@@ -219,13 +298,20 @@ export function render() {
compressionValues = { ...COMPRESSION_DEFAULTS, ...(data?.values || {}) }
}
async function loadToolGuardrails() {
const data = await api.hermesToolLoopGuardrailsConfigRead()
toolGuardrailsValues = { ...TOOL_GUARDRAILS_DEFAULTS, ...(data?.values || {}) }
}
async function load() {
loading = true
runtimeLoading = true
compressionLoading = true
toolGuardrailsLoading = true
error = null
runtimeError = null
compressionError = null
toolGuardrailsError = null
draw()
try {
await loadRaw()
@@ -250,6 +336,14 @@ export function render() {
compressionLoading = false
draw()
}
try {
await loadToolGuardrails()
} catch (err) {
toolGuardrailsError = humanizeError(err, t('engine.hermesToolGuardrailsLoadFailed') || 'Load tool guardrail config failed')
} finally {
toolGuardrailsLoading = false
draw()
}
}
async function refreshRawAfterStructuredSave() {
@@ -277,6 +371,9 @@ export function render() {
try {
await loadCompression()
} catch {}
try {
await loadToolGuardrails()
} catch {}
} catch (err) {
error = humanizeError(err, t('engine.hermesConfigSaveFailed') || 'Save failed')
toast(error, 'error')
@@ -345,6 +442,38 @@ export function render() {
}
}
async function saveToolGuardrails() {
const form = {
warningsEnabled: !!el.querySelector('#hm-tool-guardrails-warnings-enabled')?.checked,
hardStopEnabled: !!el.querySelector('#hm-tool-guardrails-hard-stop-enabled')?.checked,
warnExactFailure: el.querySelector('#hm-tool-guardrails-warn-exact-failure')?.value || '2',
warnSameToolFailure: el.querySelector('#hm-tool-guardrails-warn-same-tool-failure')?.value || '3',
warnNoProgress: el.querySelector('#hm-tool-guardrails-warn-no-progress')?.value || '2',
hardStopExactFailure: el.querySelector('#hm-tool-guardrails-hard-stop-exact-failure')?.value || '5',
hardStopSameToolFailure: el.querySelector('#hm-tool-guardrails-hard-stop-same-tool-failure')?.value || '8',
hardStopNoProgress: el.querySelector('#hm-tool-guardrails-hard-stop-no-progress')?.value || '5',
}
toolGuardrailsSaving = true
toolGuardrailsError = null
draw()
try {
const result = await api.hermesToolLoopGuardrailsConfigSave(form)
toolGuardrailsValues = { ...TOOL_GUARDRAILS_DEFAULTS, ...(result?.values || form) }
await refreshRawAfterStructuredSave()
const backup = result?.backup || ''
toast({
message: t('engine.hermesToolGuardrailsSaveSuccess'),
hint: backup ? t('engine.hermesConfigBackupHint', { path: backup }) : '',
}, 'success')
} catch (err) {
toolGuardrailsError = humanizeError(err, t('engine.hermesToolGuardrailsSaveFailed') || 'Save tool guardrail config failed')
toast(toolGuardrailsError, 'error')
} finally {
toolGuardrailsSaving = false
draw()
}
}
draw()
load()
return el

12
src/engines/hermes/style/hermes.css
View File

@@ -6757,6 +6757,17 @@ body[data-active-engine="hermes"][data-theme="dark"] {
grid-template-columns: repeat(4, minmax(140px, 1fr));
margin-top: 18px;
}
[data-engine="hermes"] .hm-config-guardrails-grid {
grid-template-columns: repeat(3, minmax(160px, 1fr));
margin-top: 12px;
}
[data-engine="hermes"] .hm-config-subtitle {
margin-top: 20px;
color: var(--hm-text-secondary);
font-family: var(--hm-font-serif);
font-size: 13px;
font-weight: 500;
}
[data-engine="hermes"] .hm-config-check-grid {
display: grid;
grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -6881,6 +6892,7 @@ body[data-active-engine="hermes"][data-theme="dark"] {
}
[data-engine="hermes"] .hm-config-runtime-grid,
[data-engine="hermes"] .hm-config-compression-grid,
[data-engine="hermes"] .hm-config-guardrails-grid,
[data-engine="hermes"] .hm-config-check-grid {
grid-template-columns: 1fr;
}

2
src/lib/tauri-api.js
View File

@@ -513,6 +513,8 @@ export const api = {
hermesSessionRuntimeConfigSave: (form) => invoke('hermes_session_runtime_config_save', { form }),
hermesCompressionConfigRead: () => invoke('hermes_compression_config_read'),
hermesCompressionConfigSave: (form) => invoke('hermes_compression_config_save', { form }),
hermesToolLoopGuardrailsConfigRead: () => invoke('hermes_tool_loop_guardrails_config_read'),
hermesToolLoopGuardrailsConfigSave: (form) => invoke('hermes_tool_loop_guardrails_config_save', { form }),
hermesLazyDepsFeatures: () => cachedInvoke('hermes_lazy_deps_features', {}, 600000),
hermesLazyDepsStatus: (features) => invoke('hermes_lazy_deps_status', { features }),
hermesLazyDepsEnsure: (feature) => invoke('hermes_lazy_deps_ensure', { feature }),

18
src/locales/modules/engine.js
View File

@@ -512,6 +512,24 @@ export default {
hermesCompressionProtectFirstN: _('保护开头消息数', 'Protect first messages', '保護開頭訊息數'),
hermesCompressionAbortOnSummaryFailure: _('摘要失败时中止回复', 'Abort when summarization fails', '摘要失敗時中止回覆'),
hermesCompressionFootnote: _('阈值和目标比例越低，压缩越早、越激进。建议先使用默认值，再根据真实 Gateway 日志调整。', 'Lower thresholds and target ratios compress earlier and more aggressively. Start with the defaults, then tune with real Gateway logs.', '閾值和目標比例越低，壓縮越早、越激進。建議先使用預設值，再根據真實 Gateway 日誌調整。'),
hermesToolGuardrailsTitle: _('工具循环防护', 'Tool loop guardrails', '工具循環防護'),
hermesToolGuardrailsDesc: _('当 Agent 重复失败或反复执行无进展工具时，先给模型修正提示；开启硬停止后可主动中止失控循环。', 'Warn the model when tools repeat failures or make no progress. Enable hard stops to halt runaway loops before they spend the full turn budget.', '當 Agent 重複失敗或反覆執行無進展工具時，先給模型修正提示；啟用硬停止後可主動中止失控循環。'),
hermesToolGuardrailsStatusReady: _('结构化配置', 'structured settings', '結構化設定'),
hermesToolGuardrailsSave: _('保存防护配置', 'Save guardrail settings', '儲存防護設定'),
hermesToolGuardrailsSaveSuccess: _('工具循环防护已保存，建议重启 Hermes Gateway 生效', 'Tool loop guardrails saved. Restart Hermes Gateway to take effect.', '工具循環防護已儲存，建議重啟 Hermes Gateway 生效'),
hermesToolGuardrailsLoadFailed: _('加载工具循环防护失败', 'Load tool loop guardrails failed', '載入工具循環防護失敗'),
hermesToolGuardrailsSaveFailed: _('保存工具循环防护失败', 'Save tool loop guardrails failed', '儲存工具循環防護失敗'),
hermesToolGuardrailsWarningsEnabled: _('启用软警告', 'Enable soft warnings', '啟用軟警告'),
hermesToolGuardrailsHardStopEnabled: _('启用硬停止', 'Enable hard stops', '啟用硬停止'),
hermesToolGuardrailsWarnAfterTitle: _('软警告阈值', 'Soft warning thresholds', '軟警告閾值'),
hermesToolGuardrailsHardStopAfterTitle: _('硬停止阈值', 'Hard stop thresholds', '硬停止閾值'),
hermesToolGuardrailsWarnExactFailure: _('相同失败警告', 'Exact failure warning', '相同失敗警告'),
hermesToolGuardrailsWarnSameToolFailure: _('同工具失败警告', 'Same-tool failure warning', '同工具失敗警告'),
hermesToolGuardrailsWarnNoProgress: _('无进展警告', 'No-progress warning', '無進展警告'),
hermesToolGuardrailsHardStopExactFailure: _('相同失败停止', 'Exact failure stop', '相同失敗停止'),
hermesToolGuardrailsHardStopSameToolFailure: _('同工具失败停止', 'Same-tool failure stop', '同工具失敗停止'),
hermesToolGuardrailsHardStopNoProgress: _('无进展停止', 'No-progress stop', '無進展停止'),
hermesToolGuardrailsFootnote: _('默认只提示不拦截，适合交互式使用。硬停止更适合 cron、无人值守和长时间后台任务。', 'By default Hermes only warns and does not block, which fits interactive use. Hard stops are better for cron, unattended, and long-running background jobs.', '預設只提示不攔截，適合互動式使用。硬停止更適合 cron、無人值守和長時間背景任務。'),
// Batch 1 §E: 会话导出
sessionsExport: _('导出', 'Export', '匯出'),
sessionsExportSuccess: _('已导出', 'Exported', '已匯出'),

35
tests/hermes-config-page-ui.test.js Normal file
View File

@@ -0,0 +1,35 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import { readFileSync } from 'node:fs'
import { t } from '../src/lib/i18n.js'
const source = readFileSync(new URL('../src/engines/hermes/pages/config.js', import.meta.url), 'utf8')
function extractEngineKeys() {
return [...source.matchAll(/['"](engine\.[A-Za-z0-9_.-]+)['"]/g)].map(match => match[1])
}
test('Hermes 配置页会暴露工具循环防护结构化配置字段', () => {
for (const id of [
'hm-tool-guardrails-save',
'hm-tool-guardrails-warnings-enabled',
'hm-tool-guardrails-hard-stop-enabled',
'hm-tool-guardrails-warn-exact-failure',
'hm-tool-guardrails-warn-same-tool-failure',
'hm-tool-guardrails-warn-no-progress',
'hm-tool-guardrails-hard-stop-exact-failure',
'hm-tool-guardrails-hard-stop-same-tool-failure',
'hm-tool-guardrails-hard-stop-no-progress',
]) {
assert.match(source, new RegExp(`id="${id}"`), `缺少 ${id}`)
}
})
test('Hermes 配置页新增结构化配置不会暴露翻译 key', () => {
const keys = new Set(extractEngineKeys().filter(key => key.includes('ToolGuardrails')))
assert.ok(keys.size > 0, '应能提取工具循环防护用到的 engine 翻译 key')
for (const key of keys) {
assert.notEqual(t(key), key, `${key} 缺少运行时翻译`)
}
})

106
tests/hermes-tool-loop-guardrails-config.test.js Normal file
View File

@@ -0,0 +1,106 @@
import test from 'node:test'
import assert from 'node:assert/strict'
import {
buildHermesToolLoopGuardrailsConfigValues,
mergeHermesToolLoopGuardrailsConfig,
} from '../scripts/dev-api.js'
test('Hermes 工具循环防护读取会提供上游默认值', () => {
const values = buildHermesToolLoopGuardrailsConfigValues({})
assert.deepEqual(values, {
warningsEnabled: true,
hardStopEnabled: false,
warnExactFailure: 2,
warnSameToolFailure: 3,
warnNoProgress: 2,
hardStopExactFailure: 5,
hardStopSameToolFailure: 8,
hardStopNoProgress: 5,
})
})
test('Hermes 工具循环防护读取会回显嵌套阈值字段', () => {
const values = buildHermesToolLoopGuardrailsConfigValues({
tool_loop_guardrails: {
warnings_enabled: false,
hard_stop_enabled: true,
warn_after: {
exact_failure: 3,
same_tool_failure: 4,
idempotent_no_progress: 5,
},
hard_stop_after: {
exact_failure: 6,
same_tool_failure: 7,
idempotent_no_progress: 8,
},
},
})
assert.equal(values.warningsEnabled, false)
assert.equal(values.hardStopEnabled, true)
assert.equal(values.warnExactFailure, 3)
assert.equal(values.warnSameToolFailure, 4)
assert.equal(values.warnNoProgress, 5)
assert.equal(values.hardStopExactFailure, 6)
assert.equal(values.hardStopSameToolFailure, 7)
assert.equal(values.hardStopNoProgress, 8)
})
test('Hermes 工具循环防护保存会保留无关 YAML 并写入上游嵌套结构', () => {
const next = mergeHermesToolLoopGuardrailsConfig({
model: { provider: 'anthropic' },
tool_loop_guardrails: {
warnings_enabled: true,
custom_flag: 'keep-me',
warn_after: {
exact_failure: 2,
custom_warn: 99,
},
},
streaming: { enabled: true },
}, {
warningsEnabled: false,
hardStopEnabled: true,
warnExactFailure: '3',
warnSameToolFailure: '4',
warnNoProgress: '5',
hardStopExactFailure: '6',
hardStopSameToolFailure: '7',
hardStopNoProgress: '8',
})
assert.deepEqual(next.model, { provider: 'anthropic' })
assert.deepEqual(next.streaming, { enabled: true })
assert.equal(next.tool_loop_guardrails.warnings_enabled, false)
assert.equal(next.tool_loop_guardrails.hard_stop_enabled, true)
assert.equal(next.tool_loop_guardrails.custom_flag, 'keep-me')
assert.equal(next.tool_loop_guardrails.warn_after.exact_failure, 3)
assert.equal(next.tool_loop_guardrails.warn_after.same_tool_failure, 4)
assert.equal(next.tool_loop_guardrails.warn_after.idempotent_no_progress, 5)
assert.equal(next.tool_loop_guardrails.warn_after.custom_warn, 99)
assert.equal(next.tool_loop_guardrails.hard_stop_after.exact_failure, 6)
assert.equal(next.tool_loop_guardrails.hard_stop_after.same_tool_failure, 7)
assert.equal(next.tool_loop_guardrails.hard_stop_after.idempotent_no_progress, 8)
})
test('Hermes 工具循环防护保存会拒绝越界阈值', () => {
assert.throws(
() => mergeHermesToolLoopGuardrailsConfig({}, { warnExactFailure: '0' }),
/tool_loop_guardrails\.warn_after\.exact_failure/,
)
assert.throws(
() => mergeHermesToolLoopGuardrailsConfig({}, { warnSameToolFailure: '101' }),
/tool_loop_guardrails\.warn_after\.same_tool_failure/,
)
assert.throws(
() => mergeHermesToolLoopGuardrailsConfig({}, { hardStopExactFailure: '0' }),
/tool_loop_guardrails\.hard_stop_after\.exact_failure/,
)
assert.throws(
() => mergeHermesToolLoopGuardrailsConfig({}, { hardStopNoProgress: '101' }),
/tool_loop_guardrails\.hard_stop_after\.idempotent_no_progress/,
)
})