Skip to content
Closed
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
45 changes: 44 additions & 1 deletion ga.py
Original file line number Diff line number Diff line change
Expand Up @@ -464,8 +464,24 @@ def do_update_working_checkpoint(self, args, response):
return StepOutcome({"result": "working key_info updated"}, next_prompt=next_prompt)

def _retry_or_exit(self, prompt):
"""Give up after 3 consecutive unusable replies — but say so first.

Returning `StepOutcome({}, should_exit=True)` with nothing printed makes the
front end go quiet mid-task: the user sees the turn stop with no error and no
explanation. That is the same "silent stop" the guards above are meant to
prevent, so the give-up path must be visible too.
"""
self._empty_ct = getattr(self, '_empty_ct', 0) + 1
if self._empty_ct >= 3: return StepOutcome({}, should_exit=True)
if self._empty_ct >= 3:
note = (f"\n[任务中止] 模型连续 {self._empty_ct} 次未产出有效回复"
f"(空响应/仅 <summary>/工具格式无效),已停止本轮任务。\n"
f"建议: 重发该任务,或为该渠道降低 reasoning_effort / 提高 max_tokens。\n")
try:
self.history_info.append('[Agent] ' + note.strip().replace('\n', ' '))
except Exception:
pass
yield note
return StepOutcome({}, should_exit=True)
return StepOutcome({}, next_prompt=prompt)

def do_no_tool(self, args, response):
Expand All @@ -484,6 +500,33 @@ def do_no_tool(self, args, response):
return self._retry_or_exit("[ERROR] Tool call format invalid; no tool was called. Regenerate using proper tool calls.")
if 'max_tokens !!!]' in content[-100:]:
return self._retry_or_exit("[ERROR] max_tokens limit reached. Use multi small steps to do it.")

# 2026-11-11: 伪 XML 工具块冒充最终回答。
# llmcore 认得出来的(成对闭合 + 参数可重建 + 脚本能通过语法校验)已在
# `_parse_text_tool_calls` 里还原成真 tool_calls, 走到这里的一定是「想调工具但没调成」:
# unclosed = 流被掐断在半截(max_tokens / 流中断);
# empty = 块闭合但一个参数都没有(用户看到的 `</code_run><code_run></code_run>`);
# orphan = 只有 <parameter> 没有工具名(`<type>` 包裹的那种);
# invalid = 块闭合但重建出来的调用不可安全执行(半截脚本 / 语法错)。
# 任何一条都不能当最终回答交付, 否则本轮任务静默结束且不报错。
_residue = None
try:
import llmcore as _llmcore
_residue = _llmcore.textual_tool_residue(content)
except Exception:
_residue = None
if _residue:
_why = {
'unclosed': 'an unterminated textual tool block (the stream was cut mid-call)',
'empty': 'a textual tool block with no arguments',
'orphan': 'textual parameters without a tool name',
'invalid': 'a textual tool block that cannot be executed safely',
}.get(_residue, 'a textual tool block')
yield f"[Info] Detected {_why}. Regenerating.\n"
return self._retry_or_exit(
"[ERROR] Your tool call was emitted as plain XML text (%s) and no tool was executed. "
"Regenerate using the native tool-call interface — not <code_run>/<parameter>/<function=>/DSML text, "
"and make sure the whole call is emitted in one piece." % _why)

# 2. 检测"包含较大代码块但未调用工具"的情况
# 关键特征:恰好1个大代码块 + 代码块直接结尾(后面只有空白)
Expand Down
268 changes: 268 additions & 0 deletions llmcore.py
Original file line number Diff line number Diff line change
Expand Up @@ -934,8 +934,276 @@ def _parse_text_tool_calls(content):
if name: tcs.append(MockToolCall(name, args))
except: pass
if tcs: content = re.sub(_xp, "", content, flags=re.DOTALL).strip()
if not tcs:
tcs, content = _parse_pseudo_xml_tool_calls(content)
return tcs, content

# ==== 伪 XML 工具调用兜底 (2026-11-11) ==================================
# 现象: 部分上游不用原生 tool_calls, 而是把工具调用写成**伪 XML 正文**:
# <code_run>\n<script>print(1)</script>\n</code_run>
# <code_run>\n<parameter name="script">print(1)</parameter>\n</code_run>
# <file_read">\n<parameter name="path">a.py</parameter>\n</file_read> (名字后多一个引号)
# <function=code_run><parameter=script>print(1)</parameter></function> (Qwen 风格)
# <||DSML||tool_calls><||DSML||invoke name="code_run"><||DSML||parameter name="script">… (DeepSeek DSML)
# `_parse_text_tool_calls` 只认 `<tool_use>`/`<tool_call>` + JSON, 这些一个都认不出
# ⇒ tool_calls 为空 ⇒ `ga.do_no_tool` 又一条判据都不命中 ⇒ 被当成**最终回答**
# ⇒ 本轮任务结束。用户观感 = 「冒出一坨标签然后对话自己中断了, 且不报错」。
#
# 安全约束(宁可不解析, 不可乱执行):
# * 工具名必须在白名单内(assets/tools_schema.json + 常见别名), 正文里的任意 <xxx> 不猜;
# * 只认**成对闭合**的块 —— 流被掐断在半截时不猜参数;
# * ``` 围栏 / `行内代码` 内的内容不参与匹配 —— 模型讲解/写文档时提到这些标签不应被真执行;
# * 解析结果还要过 `salvaged_call_problem`(python 语法等) —— 压平成一行/半截的脚本
# 宁可让模型重发, 也不能直接跑起来。
#
# ★ 2026-11-11 PR #853 review 修复的三处缺口:
# C 参数名被写成 dsml_parameter —— 参数名解析与工具标签的引号风格解耦;
# F `<function=name><parameter=k>` 还原(此前直接静默终答);
# H 截断的调用被当真正调用执行 —— 安全闸门挪到 `_parse_text_tool_calls` 返回之前,
# 而不是等 do_no_tool; 另外 `textual_tool_residue` 把「想调但调不成」的残渣
# (unclosed/empty/orphan) 交给 ga 重试, 不再冒充最终回答。
import ast

_PSEUDO_XML_ALIASES = frozenset({
'code_run', 'file_read', 'file_write', 'file_patch', 'web_scan', 'web_execute_js',
'web_search', 'web_fetch', 'update_working_checkpoint', 'start_long_term_update',
'ask_user', 'all_urls', 'bad_json', 'computer', 'bash', 'powershell',
})
_TOOL_NAMES_CACHE = None
# `||DSML||` 前缀(全角/半角竖线都见过), 可选
_DSML = r'(?:\s*[\uff5c|]{1,2}\s*DSML\s*[\uff5c|]{1,2}\s*)?'
# 工具名与 '>' 之间的杂音: 多余引号/空白(实测 `<file_read">`)
_NOISE = r'[ \t"\']{0,4}'
# 行首锚定 —— 正文里顺手提到 `<code_run>` 不算泄漏, 真的泄漏总是独立成行
_BOL = r'(?m)^[ \t]*'


def _known_tool_names():
"""白名单: 内置别名 ∪ assets/tools_schema.json 里声明的工具名。"""
global _TOOL_NAMES_CACHE
if _TOOL_NAMES_CACHE is not None: return _TOOL_NAMES_CACHE
names = set(_PSEUDO_XML_ALIASES)
try:
with open(os.path.join(_ROOT, 'assets', 'tools_schema.json'), encoding='utf-8') as f:
for t in json.load(f):
fn = t.get('function', t) or {}
if fn.get('name'): names.add(fn['name'])
except Exception:
pass
_TOOL_NAMES_CACHE = frozenset(names)
return _TOOL_NAMES_CACHE


def _mask_code(text):
"""把 ``` 围栏 / `行内代码` 换成等长空格(保持偏移不变)。

★哨兵不能用 0: 围栏正好从第 0 个字符开始时, `pos == 0` 会被误判成「还没开」,
于是永远不闭合 —— 负例(整段被 ``` 包住)反而会被当真调用执行。
"""
out = list(text)
for m in re.finditer(r'```[\s\S]*?(?:```|$)', text):
for i in range(m.start(), m.end()): out[i] = ' '
for m in re.finditer(r'`[^`\n]*`', text):
for i in range(m.start(), m.end()): out[i] = ' '
return ''.join(out)


class _Scan:
__slots__ = ('blocks', 'unclosed', 'orphans')

def __init__(self):
self.blocks = [] # dict(start, end, name, body, attrs)
self.unclosed = [] # 有开无闭的块/参数(通常是流被掐断)
self.orphans = [] # 落在任何工具块之外的 <parameter>(想调工具但没调成)


def _scan_pseudo_xml(content):
"""扫描正文里的伪工具块。

只看**行首**开标签(正文里 inline 提到标签不算), 围栏/行内代码内全部忽略。
"""
sc = _Scan()
if not content: return sc
text = _mask_code(content)
names = _known_tool_names()
alt = '|'.join(sorted((re.escape(n) for n in names if n), key=len, reverse=True))

# 三种开标签: <工具名 ...> / <function=工具名> / <invoke name="工具名">
opens = []
for m in re.finditer(_BOL + r'<' + _DSML + r'(' + alt + r')\b' + _NOISE + r'([^<>]{0,200})>', text, re.I):
opens.append((m.start(), m.end(), m.group(1), m.group(2) or '', 'tag'))
for m in re.finditer(_BOL + r'<function\s*=\s*["\']?([A-Za-z_]\w*)["\']?\s*>', text, re.I):
opens.append((m.start(), m.end(), m.group(1), '', 'function'))
for m in re.finditer(_BOL + r'<' + _DSML + r'invoke\s+name\s*=\s*["\']?([A-Za-z_]\w*)["\']?\s*>', text, re.I):
opens.append((m.start(), m.end(), m.group(1), '', 'invoke'))
opens.sort()

spans = []
for start, end, name, attrs, form in opens:
if name not in names: continue
if any(a <= start < b for a, b in spans): continue # 嵌套在外层块里
if form == 'function':
close_re = re.compile(r'</function\s*>', re.I)
elif form == 'invoke':
close_re = re.compile(r'</' + _DSML + r'invoke\s*>', re.I)
else:
close_re = re.compile(r'</' + _DSML + re.escape(name) + r'\s*>', re.I)
c = close_re.search(text, end)
if c is None:
sc.unclosed.append(name); continue
body = content[end:c.start()]
spans.append((start, c.end()))
sc.blocks.append({'start': start, 'end': c.end(), 'name': name, 'body': body, 'attrs': attrs})

spans.sort()
# 落在所有工具块之外的 <parameter> = 形状 D(<type> 包 parameter): 没有任何工具名,
# 重建不了, 只能当残渣重试 —— 绝不能当最终回答交付。
# 同样行首锚定: 正文里"用法: <parameter name=…>"这种说明句不该触发重试。
for m in re.finditer(_BOL + r'<' + _DSML + r'parameter\b[^<>]*>', text, re.I):
if any(a <= m.start() < b for a, b in spans): continue
sc.orphans.append('parameter')
# 块内参数有开无闭 = 截断(例如 </code_run> 到了但 </parameter> 没到)
for b in sc.blocks:
if b['body'].count('<parameter') > b['body'].count('</parameter'):
sc.unclosed.append(b['name'])
return sc


def _coerce(k, v):
"""参数值按名字收敛类型: timeout 等转 int, 布尔开关转 bool。"""
if not isinstance(v, str): return v
s = v.strip()
if k in ('timeout', 'start', 'count', 'maxlen') and re.fullmatch(r'-?\d+', s): return int(s)
if k in ('show_linenos', 'tabs_only', 'text_only', 'no_monitor', 'inline_eval'):
return s.lower() in ('true', '1', 'yes')
return v


def _pseudo_xml_args(body, name, attrs=''):
"""从块体/开标签属性里抽参数。抽不出返回 {}。"""
args = {}
for k, v in re.findall(r'([A-Za-z_][\w-]*)\s*=\s*["\']([^"\']*)["\']', attrs or ''):
args[k] = _coerce(k, v)
m = re.search(r'<' + _DSML + r'script[^<>]*>(.*?)</' + _DSML + r'script\s*>', body, re.DOTALL | re.I)
if m: args.setdefault('script', m.group(1).strip('\n'))
# 参数名解析与工具标签的引号风格解耦: `parameter name="k"` / `parameter name='k'` /
# `parameter=k` / `parameter name=k` 全部认。标签上的 `string="true"` 等属性不参与。
for pm in re.finditer(r'<' + _DSML + r'parameter\s*(?:name\s*)?=\s*["\']?([\w.-]+)["\']?[^<>]*>'
r'(.*?)</' + _DSML + r'parameter\s*>', body, re.DOTALL | re.I):
k = pm.group(1)
if k and k.lower() not in ('string', 'true', 'false', 'type'):
args.setdefault(k, _coerce(k, pm.group(2).strip('\n')))
if args: return args
b = (body or '').strip()
if not b: return {}
if b[0] in '{[':
try:
d = json.loads(b)
if isinstance(d, dict): return d
except Exception:
pass
if name in ('code_run', 'bash', 'powershell') and '<' not in b:
return {'script': b}
return {}


_SHELL_HEAD = re.compile(
r'^\s*(ls|cd|pwd|dir|echo|cat|git|pip|pip3|npm|curl|wget|ssh|scp|mkdir|rm|cp|mv|chmod|'
r'python3?|bash|sh|zsh|node|docker|kubectl)\b')


def salvaged_call_problem(call):
"""抢救出来的调用能不能安全执行。返回问题描述, '' 表示没问题。

宁可让模型重发, 也不能把半截/压平成一段的脚本直接跑起来。
"""
fn = getattr(call, 'function', None)
name = getattr(fn, 'name', '') or ''
if not name: return 'tool name is empty'
try:
args = json.loads(getattr(fn, 'arguments', '') or '{}')
except Exception as e:
return 'arguments are not valid JSON: %s' % e
if not isinstance(args, dict): return 'arguments are not an object'
if name in ('code_run', 'code_exec', 'bash', 'powershell'):
code = args.get('script') or args.get('code') or ''
if not str(code).strip(): return 'script is empty'
ctype = str(args.get('type') or '').lower()
if not ctype: ctype = 'shell' if _SHELL_HEAD.match(str(code)) else 'python'
if ctype in ('python', 'py'):
try:
ast.parse(str(code))
except SyntaxError as e:
return 'python syntax error (line %s: %s)' % (e.lineno, e.msg)
elif name in ('file_read', 'file_write', 'file_patch'):
if not args.get('path'): return 'path is empty'
return ''


def leaked_markup_incomplete(text):
"""伪工具块是否被截断(流中断 / max_tokens)。True = 残块, 绝不能执行。"""
try:
if not text: return False
return bool(_scan_pseudo_xml(text).unclosed)
except Exception:
return False


def textual_tool_residue(content):
"""正文里是否残留**调不成**的伪工具块。

返回 'unclosed'(有开无闭, 通常是流被掐断) / 'empty'(块闭合但没参数) /
'orphan'(有 <parameter> 却没有工具名) / 'invalid'(块闭合但重建的调用不可安全执行) / None。
一旦命中就绝不能当最终回答交付:
用户看到的「冒出一坨标签然后对话自己中断了」就是这条路径。
"""
try:
if not content: return None
sc = _scan_pseudo_xml(content)
if sc.unclosed: return 'unclosed'
if sc.orphans: return 'orphan'
for b in sc.blocks:
args = _pseudo_xml_args(b['body'], b['name'], b['attrs'])
if not args: return 'empty'
# 块是闭合的, 但重建出来的调用不可安全执行(半截脚本/语法错) —— 同样是残渣。
# 这类不能在 `_parse_pseudo_xml_tool_calls` 里静默丢掉(那样会被当最终回答)。
if salvaged_call_problem(MockToolCall(b['name'], args)): return 'invalid'
return None
except Exception:
return None


def _parse_pseudo_xml_tool_calls(content):
"""把伪 XML 工具块还原成 MockToolCall。返回 (tcs, 去掉块后的正文)。

★ 安全闸门放在**这个函数内部**(即 `_parse_text_tool_calls` 返回之前), 而不是
`ga.do_no_tool`: 半截调用一旦变成真 tool_calls, 就会先走执行路径 ——
PR #853 的 H 正是这样被执行的。`leaked_markup_incomplete` 和
`salvaged_call_problem` 在这里就把它们拦下, 宁可让模型重发。
"""
try:
sc = _scan_pseudo_xml(content)
if not sc.blocks: return [], content
if textual_tool_residue(content): return [], content # unclosed / empty / orphan
found = []
for b in sorted(sc.blocks, key=lambda x: x['start']):
args = _pseudo_xml_args(b['body'], b['name'], b['attrs'])
if not args: return [], content
call = MockToolCall(b['name'], args)
if salvaged_call_problem(call): return [], content # 半截/坏脚本不许执行
found.append(call)
rest, last = [], 0
for b in sorted(sc.blocks, key=lambda x: x['start']):
if b['start'] < last: continue
rest.append(content[last:b['start']]); last = b['end']
rest.append(content[last:])
tail = ''.join(rest)
tail = re.sub(r'</?' + _DSML + r'(?:tool_calls|function_calls|invoke|function)\s*>', '', tail, flags=re.I)
return found, tail.strip()
except Exception as e:
print('[WARN] _parse_pseudo_xml_tool_calls failed: %s' % e)
return [], content

def _ensure_text_block(blocks):
"""If response has thinking but no text block, inject a synthetic summary from thinking's first line."""
if any(b.get("type") == "text" for b in blocks): return None
Expand Down
Loading