morluto/rea

Fork 0

mirror of https://github.com/morluto/rea.git synced 2026-11-05 06:45:22 +00:00

[GH-ISSUE #1212] [Bug] MCP tool schemas emit regex patterns rejected under strict-mode validation (observe_native_calls blocks the whole request) #428

New issue

Closed

opened 2026-10-15 18:24:58 +00:00 by bsakaguchi · 1 comment

bsakaguchi commented

2026-10-15 18:24:58 +00:00

Owner

Originally created by @chengong-art on GitHub (Oct 9, 2026).
Original GitHub issue: https://github.com/morluto/rea/issues/1212

Before submitting

I searched the open and closed issues for a related report. The closest is #1052 (providers rejecting function schemas, aborting the whole request); that was a root anyOf shape problem. This is a different defect: the content of emitted pattern strings is not a valid regex under strict modes.
I removed credentials, tokens, private paths, and sensitive target data.

Area

MCP or agent integration

Observed behavior

When REA's tools/list output is handed to a provider that validates tool parameters with format: "regex", the request is rejected before the model runs and no tool is ever dispatched:

Invalid schema for function 'mcp__rea__observe_native_calls': "^[^\s[\]]+$" is not a "regex"

The failing pattern comes from objcName, used by breakpoints[].selector and breakpoints[].class_name in observe_native_calls. src/domain/native/nativeCallObservation.ts (still current on main, last touched by 70e8a8f8 on 2026-10-08):

const objcName = nativeString
  .min(1)
  .regex(/^[^\s[\]]+$/u, "Use the bare name without spaces or brackets");

z.toJSONSchema({ target: "draft-2020-12" }) copies regex.source verbatim into the schema as ^[^\\s[\\]]+$, i.e. the pattern text ^[^\s[\]]+$. An unescaped [ inside a character class is accepted by Annex-B and u-mode parsing, but rejected by v-mode parsing — and by Ruby.

It is not one field. I ran a real initialize + tools/list handshake against the installed server and compiled every emitted pattern (351 fields across 138 tools) in each flag mode:

71 fields are rejected under the v flag; they reduce to 9 unique patterns.
All 71 compile fine with no flag and with u, so the defect is invisible to REA's own runtime validation (Zod uses u) and to u-based validators.
Affected tools, by rejected-field count: evaluate_reconstruction_coverage 24, capture_browser_scenario 18, compare_process_captures 11, build_reconstruction_obligation_ledger 9, verify_reconstruction 3, observe_native_calls 2, build_call_path 2, open_binary 1, compare_source_to_bundle 1.
Cross-engine check of the same strings: Python re and Perl accept all of them; Ruby rejects the objcName one (premature end of char-class) and accepts the -// ones. So the fleet issue is v-mode specific, while ^[^\s[\]]+$ is the only one that is genuinely malformed outside JS too.

Two things I had to get right, since both are easy to assert wrongly: u and v cannot be combined (new RegExp(p,"uv") throws Invalid flags), and inside a u-mode class you may only escape the syntactically-meaningful set — \: \% \~ \_ are themselves Invalid escape. A blanket "escape everything" sweep would break these schemas in the opposite direction.

Reproduction

No target artifact needed — pure schema validation.

// repro.mjs — node repro.mjs   (adjust path to scripts/rea.mjs)
import { spawn } from "node:child_process";
const child = spawn(process.execPath, ["node_modules/rea-agents/scripts/rea.mjs", "mcp"],
  { stdio: ["pipe", "pipe", "pipe"] });
let buf = ""; const pending = new Map();
child.stdout.on("data", d => {
  buf += d; let i;
  while ((i = buf.indexOf("\n")) >= 0) {
    const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
    if (!line) continue;
    try { const m = JSON.parse(line); pending.get(m.id)?.(m); pending.delete(m.id); } catch {}
  }
});
const send = (method, params, id) => new Promise(r => { pending.set(id, r);
  child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n"); });
await send("initialize", { protocolVersion: "2024-11-05", capabilities: {},
  clientInfo: { name: "repro", version: "0" } }, 1);
child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n");
const list = await send("tools/list", {}, 2);

const bad = []; let total = 0;
const walk = (n, tool, path) => {
  if (Array.isArray(n)) return n.forEach((v, k) => walk(v, tool, `${path}[${k}]`));
  if (n && typeof n === "object") for (const [k, v] of Object.entries(n)) {
    if (k === "pattern" && typeof v === "string") {
      total++;
      for (const f of ["", "u", "v"]) {
        try { new RegExp(v, f); } catch (e) {
          bad.push({ tool, path: `${path}.${k}`, flag: f || "none", pattern: v, error: e.message });
        }
      }
    } else walk(v, tool, `${path}.${k}`);
  }
};
for (const t of (list.result?.tools ?? [])) walk(t.inputSchema, t.name, "");
console.log({ tools: list.result.tools.length, patternFields: total, rejectedFields: bad.length });
console.log(bad.filter(b => b.tool === "observe_native_calls"));
child.kill();

Actual output on rea-agents@6.1.0:

{ tools: 138, patternFields: 351, rejectedFields: 71 }
[
  { tool: 'observe_native_calls',
    path: '.properties.breakpoints.items.oneOf[1].properties.selector.allOf[1].pattern',
    flag: 'v', pattern: '^[^\\s[\\]]+$',
    error: 'Invalid regular expression: /^[^\\s[\\]]+$/v: Unterminated character class' },
  { tool: 'observe_native_calls',
    path: '.properties.breakpoints.items.oneOf[1].properties.class_name.allOf[1].pattern',
    flag: 'v', pattern: '^[^\\s[\\]]+$',
    error: 'Invalid regular expression: /^[^\\s[\\]]+$/v: Unterminated character class' }
]

One-liner for the language-level fact, no server required (note the doubled backslashes are the decoded JSON form):

node -e 'for (const f of ["","u","v"]) { try { new RegExp("^[^\\s[\\]]+$", f); console.log(`OK   /^[^\\s[\\]]+$/${f}`) } catch (e) { console.log(`FAIL /^[^\\s[\\]]+$/${f} -> ${e.message}`) } }'

Expected behavior

Every string REA emits as pattern should be a valid ECMA-262 regex in both u and v modes, so any client enforcing format: "regex" accepts the tool list. The intended grammar and semantics should not change.

Impact and scope

Directly affected here: observe_native_calls — selector/class_name can never reach a strict client, so LLDB call observation of ObjC methods is unavailable through it. Where the provider aborts the whole request on one bad schema (as in #1052), the entire REA surface is lost, not one tool.
Latent across the fleet: the other 8 patterns / 7 other tools fail the same v-mode check. They are not rejected by the provider I use today, so they are a compatibility risk rather than a current outage — I am reporting them so one sweep and one guard fix the class, not just my symptom.
Not affected: the running server. Zod compiles with u, so in-server validation, capture, evidence integrity, isolation and recovery are all correct once a call lands. This is purely a schema-interchange defect at the tools/list → provider boundary.
Not a false positive, and the intent is right: the neighbouring name field documents -[NSString length] as valid, and objcName exists precisely to reject that bracketed form for selector/class_name. Behaviour matches intent; only the serialized syntax is fragile.

REA version

rea-agents@6.1.0. npm view rea-agents dist-tags → latest: 6.1.0, so this is the current published release, and main still carries the pattern (src/domain/native/nativeCallObservation.ts @ 70e8a8f8).

Runtime and platform

Node v24.21.0 (server) and v25.9.0 (probe) — identical results, so not a single-V8 artifact
macOS 27.0, arm64
@modelcontextprotocol/server 2.3.1, Zod 4.4.3, AJV 8.20.0
Reproduced without Hopper/Ghidra: no provider is needed for tools/list

Target and artifact context

None. The defect is in the emitted schema, not in any analyzed binary, bundle, or workload.

Interface

MCP

Earliest failure stage

Request parsing or validation

Relevant output or evidence

Emitted shape (breakpoints[].selector, breakpoints[].class_name):

{ "type": "string", "minLength": 1,
  "allOf": [ { "pattern": "^[^\\0]*$" }, { "pattern": "^[^\\s[\\]]+$" } ] }

The 9 unique rejected patterns, per-mode compile result, and the offending v-mode character:

none	u	v	pattern (source text)	trigger in `v`
OK	OK	FAIL	`^[^\s[\]]+$`	unescaped `[` (also fails Ruby)
OK	OK	FAIL	`^[A-Za-z][A-Za-z0-9._-]*$`	`-` before `]`
OK	OK	FAIL	`^[a-z][a-z0-9-]*$`	`-` before `]`
OK	OK	FAIL	`^[A-Za-z][A-Za-z0-9._:/-]*$`	`/` and `-` before `]`
OK	OK	FAIL	`^[A-Za-z][A-Za-z0-9._:/-]{0,199}$`	`/` and `-` before `]`
OK	OK	FAIL	`^[\w .:@/+-]+$`	`/` and `-` before `]`
OK	OK	FAIL	`^[A-Za-z0-9_+-]+(?:\/[A-Za-z0-9_+-]+)*$`	`-` before `]`
OK	OK	FAIL	`^(?:(?:[A-Za-z0-9._~-]	%[0-9a-fA-F]{2})+:)?0[xX][0-9a-fA-F]+$`
OK	OK	FAIL	RFC 3339 date-time (`observed_at`)	`[+-]`

Verified v-mode class-syntax set in this Node: [ ] - / ( ) { } | must be escaped; . : + % ~ _ must not be (escaping %, ~, _, : yields Invalid escape under u).

Typed outcome or recovery expected

tools/list should return schemas that survive format: "regex" in u and v, so strict clients can list and call observe_native_calls. If a field's grammar cannot be expressed portably, it should ship minLength only and rely on the Zod-side check rather than emit a pattern some engines reject. No change to REA's runtime validation or error typing is wanted — that part is already correct.

Analysis or suspected cause

Source-derived, and confirmed by compiling the exact serialized strings rather than inferring from the provider message:

z.toJSONSchema writes regex.source into the schema without normalizing character-class contents for strict modes. Zod's runtime and the package's own tests use u, where an unescaped [ in a class is tolerated, so nothing inside the repo ever sees the failure. The trigger characters are the ones the v flag promotes to class syntax ([, ], -, /, and the grouping metachars). #1052 hit the same provider boundary from the shape side, which suggests tools/list output deserves an explicit emit-time guard instead of per-report patches.

Additional context

Proposed fix for the reported field — semantics byte-identical, verified:

.regex(/^[^\s\[\]]+$/u, "Use the bare name without spaces or brackets")

Accepts NSURLSession, foo:bar:; still rejects -[NSString length] and spaces (all six probe strings match the old pattern's result exactly).

For the other 8, escaping only - and / is enough and is u-safe, e.g. ^[A-Za-z][A-Za-z0-9._:\-\/]*$; I confirmed each against the originals over a sample set and found no behaviour change. A naive sweep that also escapes :/%/~/_, or that sets v on existing patterns, would break them under u — worth a check rather than a regex-over-source fixup.

Suggested regression test, so the whole class is caught at emit time instead of one tool at a time:

test("every emitted tool pattern is a valid regex in u and v", async () => {
  const { tools } = await client.listTools();
  const patterns: string[] = [];
  collectPatterns(tools.map(t => t.inputSchema), patterns);
  expect(patterns.length).toBeGreaterThan(0);
  for (const p of patterns) {
    new RegExp(p, "u");
    new RegExp(p, "v");
  }
});

Happy to open a PR for the one-line observe_native_calls fix (and the mechanical -// escapes for the other 8) — but the emit-time guard is the part I would want your call on.

Originally created by @chengong-art on GitHub (Oct 9, 2026). Original GitHub issue: https://github.com/morluto/rea/issues/1212 ### Before submitting - [x] I searched the open and closed issues for a related report. The closest is #1052 (providers rejecting function schemas, aborting the whole request); that was a root `anyOf` shape problem. This is a different defect: the *content* of emitted `pattern` strings is not a valid regex under strict modes. - [x] I removed credentials, tokens, private paths, and sensitive target data. ### Area MCP or agent integration ### Observed behavior When REA's `tools/list` output is handed to a provider that validates tool `parameters` with `format: "regex"`, the request is rejected before the model runs and no tool is ever dispatched: ```text Invalid schema for function 'mcp__rea__observe_native_calls': "^[^\s[\]]+$" is not a "regex" ``` The failing `pattern` comes from `objcName`, used by `breakpoints[].selector` and `breakpoints[].class_name` in `observe_native_calls`. `src/domain/native/nativeCallObservation.ts` (still current on `main`, last touched by `70e8a8f8` on 2026-10-08): ```ts const objcName = nativeString .min(1) .regex(/^[^\s[\]]+$/u, "Use the bare name without spaces or brackets"); ``` `z.toJSONSchema({ target: "draft-2020-12" })` copies `regex.source` verbatim into the schema as `^[^\\s[\\]]+$`, i.e. the pattern text `^[^\s[\]]+$`. An unescaped `[` inside a character class is accepted by Annex-B and `u`-mode parsing, but rejected by `v`-mode parsing — and by Ruby. **It is not one field.** I ran a real `initialize` + `tools/list` handshake against the installed server and compiled **every** emitted `pattern` (351 fields across 138 tools) in each flag mode: - **71 fields** are rejected under the `v` flag; they reduce to **9 unique patterns**. - All 71 compile fine with no flag and with `u`, so the defect is invisible to REA's own runtime validation (Zod uses `u`) and to `u`-based validators. - Affected tools, by rejected-field count: `evaluate_reconstruction_coverage` 24, `capture_browser_scenario` 18, `compare_process_captures` 11, `build_reconstruction_obligation_ledger` 9, `verify_reconstruction` 3, `observe_native_calls` 2, `build_call_path` 2, `open_binary` 1, `compare_source_to_bundle` 1. - Cross-engine check of the same strings: Python `re` and Perl accept all of them; **Ruby rejects the `objcName` one** (`premature end of char-class`) and accepts the `-`/`/` ones. So the fleet issue is `v`-mode specific, while `^[^\s[\]]+$` is the only one that is genuinely malformed outside JS too. Two things I had to get right, since both are easy to assert wrongly: `u` and `v` cannot be combined (`new RegExp(p,"uv")` throws `Invalid flags`), and inside a `u`-mode class you may only escape the syntactically-meaningful set — `\:` `\%` `\~` `\_` are themselves `Invalid escape`. A blanket "escape everything" sweep would break these schemas in the opposite direction. ### Reproduction No target artifact needed — pure schema validation. ```js // repro.mjs — node repro.mjs (adjust path to scripts/rea.mjs) import { spawn } from "node:child_process"; const child = spawn(process.execPath, ["node_modules/rea-agents/scripts/rea.mjs", "mcp"], { stdio: ["pipe", "pipe", "pipe"] }); let buf = ""; const pending = new Map(); child.stdout.on("data", d => { buf += d; let i; while ((i = buf.indexOf("\n")) >= 0) { const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1); if (!line) continue; try { const m = JSON.parse(line); pending.get(m.id)?.(m); pending.delete(m.id); } catch {} } }); const send = (method, params, id) => new Promise(r => { pending.set(id, r); child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n"); }); await send("initialize", { protocolVersion: "2024-11-05", capabilities: {}, clientInfo: { name: "repro", version: "0" } }, 1); child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }) + "\n"); const list = await send("tools/list", {}, 2); const bad = []; let total = 0; const walk = (n, tool, path) => { if (Array.isArray(n)) return n.forEach((v, k) => walk(v, tool, `${path}[${k}]`)); if (n && typeof n === "object") for (const [k, v] of Object.entries(n)) { if (k === "pattern" && typeof v === "string") { total++; for (const f of ["", "u", "v"]) { try { new RegExp(v, f); } catch (e) { bad.push({ tool, path: `${path}.${k}`, flag: f || "none", pattern: v, error: e.message }); } } } else walk(v, tool, `${path}.${k}`); } }; for (const t of (list.result?.tools ?? [])) walk(t.inputSchema, t.name, ""); console.log({ tools: list.result.tools.length, patternFields: total, rejectedFields: bad.length }); console.log(bad.filter(b => b.tool === "observe_native_calls")); child.kill(); ``` Actual output on `rea-agents@6.1.0`: ```text { tools: 138, patternFields: 351, rejectedFields: 71 } [ { tool: 'observe_native_calls', path: '.properties.breakpoints.items.oneOf[1].properties.selector.allOf[1].pattern', flag: 'v', pattern: '^[^\\s[\\]]+$', error: 'Invalid regular expression: /^[^\\s[\\]]+$/v: Unterminated character class' }, { tool: 'observe_native_calls', path: '.properties.breakpoints.items.oneOf[1].properties.class_name.allOf[1].pattern', flag: 'v', pattern: '^[^\\s[\\]]+$', error: 'Invalid regular expression: /^[^\\s[\\]]+$/v: Unterminated character class' } ] ``` One-liner for the language-level fact, no server required (note the doubled backslashes are the *decoded* JSON form): ```sh node -e 'for (const f of ["","u","v"]) { try { new RegExp("^[^\\s[\\]]+$", f); console.log(`OK /^[^\\s[\\]]+$/${f}`) } catch (e) { console.log(`FAIL /^[^\\s[\\]]+$/${f} -> ${e.message}`) } }' ``` ### Expected behavior Every string REA emits as `pattern` should be a valid ECMA-262 regex in **both** `u` and `v` modes, so any client enforcing `format: "regex"` accepts the tool list. The intended grammar and semantics should not change. ### Impact and scope - **Directly affected here:** `observe_native_calls` — `selector`/`class_name` can never reach a strict client, so LLDB call observation of ObjC methods is unavailable through it. Where the provider aborts the whole request on one bad schema (as in #1052), the entire REA surface is lost, not one tool. - **Latent across the fleet:** the other 8 patterns / 7 other tools fail the same `v`-mode check. They are not rejected by the provider I use today, so they are a compatibility risk rather than a current outage — I am reporting them so one sweep and one guard fix the class, not just my symptom. - **Not affected:** the running server. Zod compiles with `u`, so in-server validation, capture, evidence integrity, isolation and recovery are all correct once a call lands. This is purely a schema-interchange defect at the `tools/list` → provider boundary. - **Not a false positive, and the intent is right:** the neighbouring `name` field documents `-[NSString length]` as valid, and `objcName` exists precisely to reject that bracketed form for `selector`/`class_name`. Behaviour matches intent; only the serialized syntax is fragile. ### REA version `rea-agents@6.1.0`. `npm view rea-agents dist-tags` → `latest: 6.1.0`, so this is the current published release, and `main` still carries the pattern (`src/domain/native/nativeCallObservation.ts` @ `70e8a8f8`). ### Runtime and platform - Node v24.21.0 (server) and v25.9.0 (probe) — identical results, so not a single-V8 artifact - macOS 27.0, arm64 - `@modelcontextprotocol/server` 2.3.1, Zod 4.4.3, AJV 8.20.0 - Reproduced without Hopper/Ghidra: no provider is needed for `tools/list` ### Target and artifact context None. The defect is in the emitted schema, not in any analyzed binary, bundle, or workload. ### Interface MCP ### Earliest failure stage Request parsing or validation ### Relevant output or evidence Emitted shape (`breakpoints[].selector`, `breakpoints[].class_name`): ```json { "type": "string", "minLength": 1, "allOf": [ { "pattern": "^[^\\0]*$" }, { "pattern": "^[^\\s[\\]]+$" } ] } ``` The 9 unique rejected patterns, per-mode compile result, and the offending `v`-mode character: | none | u | v | pattern (source text) | trigger in `v` | |---|---|---|---|---| | OK | OK | **FAIL** | `^[^\s[\]]+$` | unescaped `[` (also fails Ruby) | | OK | OK | **FAIL** | `^[A-Za-z][A-Za-z0-9._-]*$` | `-` before `]` | | OK | OK | **FAIL** | `^[a-z][a-z0-9-]*$` | `-` before `]` | | OK | OK | **FAIL** | `^[A-Za-z][A-Za-z0-9._:/-]*$` | `/` and `-` before `]` | | OK | OK | **FAIL** | `^[A-Za-z][A-Za-z0-9._:/-]{0,199}$` | `/` and `-` before `]` | | OK | OK | **FAIL** | `^[\w .:@/+-]+$` | `/` and `-` before `]` | | OK | OK | **FAIL** | `^[A-Za-z0-9_+-]+(?:\/[A-Za-z0-9_+-]+)*$` | `-` before `]` | | OK | OK | **FAIL** | `^(?:(?:[A-Za-z0-9._~-]|%[0-9a-fA-F]{2})+:)?0[xX][0-9a-fA-F]+$` | `-` before `]` | | OK | OK | **FAIL** | RFC 3339 date-time (`observed_at`) | `[+-]` | Verified `v`-mode class-syntax set in this Node: `[ ] - / ( ) { } |` must be escaped; `. : + % ~ _` must **not** be (escaping `%`, `~`, `_`, `:` yields `Invalid escape` under `u`). ### Typed outcome or recovery expected `tools/list` should return schemas that survive `format: "regex"` in `u` and `v`, so strict clients can list and call `observe_native_calls`. If a field's grammar cannot be expressed portably, it should ship `minLength` only and rely on the Zod-side check rather than emit a pattern some engines reject. No change to REA's runtime validation or error typing is wanted — that part is already correct. ### Analysis or suspected cause Source-derived, and confirmed by compiling the exact serialized strings rather than inferring from the provider message: `z.toJSONSchema` writes `regex.source` into the schema without normalizing character-class contents for strict modes. Zod's runtime and the package's own tests use `u`, where an unescaped `[` in a class is tolerated, so nothing inside the repo ever sees the failure. The trigger characters are the ones the `v` flag promotes to class syntax (`[`, `]`, `-`, `/`, and the grouping metachars). #1052 hit the same provider boundary from the shape side, which suggests `tools/list` output deserves an explicit emit-time guard instead of per-report patches. ### Additional context Proposed fix for the reported field — semantics byte-identical, verified: ```ts .regex(/^[^\s\[\]]+$/u, "Use the bare name without spaces or brackets") ``` Accepts `NSURLSession`, `foo:bar:`; still rejects `-[NSString length]` and spaces (all six probe strings match the old pattern's result exactly). For the other 8, escaping only `-` and `/` is enough and is `u`-safe, e.g. `^[A-Za-z][A-Za-z0-9._:\-\/]*$`; I confirmed each against the originals over a sample set and found no behaviour change. A naive sweep that also escapes `:`/`%`/`~`/`_`, or that sets `v` on existing patterns, would break them under `u` — worth a check rather than a regex-over-source fixup. Suggested regression test, so the whole class is caught at emit time instead of one tool at a time: ```ts test("every emitted tool pattern is a valid regex in u and v", async () => { const { tools } = await client.listTools(); const patterns: string[] = []; collectPatterns(tools.map(t => t.inputSchema), patterns); expect(patterns.length).toBeGreaterThan(0); for (const p of patterns) { new RegExp(p, "u"); new RegExp(p, "v"); } }); ``` Happy to open a PR for the one-line `observe_native_calls` fix (and the mechanical `-`/`/` escapes for the other 8) — but the emit-time guard is the part I would want your call on.

bsakaguchi

2026-10-15 18:24:58 +00:00

closed this issue
added the
area: mcp

bug
labels

bsakaguchi commented

2026-10-15 18:24:59 +00:00

Author

Owner

@kaoru0822-kitauji commented on GitHub (Oct 9, 2026):

Resolved on main by #1220 (escaped the reserved characters in every advertised pattern and added tests/boundary/mcp/advertisedPatternsVMode.test.ts) and #1227 (shared the identifier and base64 patterns and completed the CDP metadata escapes).

Verified on main at f4c99ab8 with a real stdio initialize + tools/list handshake:

139 tools, 988 pattern fields (input and output schemas), 92 unique patterns: 0 rejected by new RegExp(p, "v").
The objcName pattern used by observe_native_calls is now emitted as ^[^\s\x5b\x5d]+$.
All 92 unique patterns also compile in Ruby 2.6 (Regexp.new) and Python re.
npx vitest run tests/boundary/mcp/advertisedPatternsVMode.test.ts passes.

Thanks for the detailed census.

@kaoru0822-kitauji commented on GitHub (Oct 9, 2026): Resolved on `main` by #1220 (escaped the reserved characters in every advertised `pattern` and added `tests/boundary/mcp/advertisedPatternsVMode.test.ts`) and #1227 (shared the identifier and base64 patterns and completed the CDP metadata escapes). Verified on `main` at f4c99ab8 with a real stdio `initialize` + `tools/list` handshake: - 139 tools, 988 `pattern` fields (input and output schemas), 92 unique patterns: **0 rejected** by `new RegExp(p, "v")`. - The `objcName` pattern used by `observe_native_calls` is now emitted as `^[^\s\x5b\x5d]+$`. - All 92 unique patterns also compile in Ruby 2.6 (`Regexp.new`) and Python `re`. - `npx vitest run tests/boundary/mcp/advertisedPatternsVMode.test.ts` passes. Thanks for the detailed census.

bsakaguchi referenced this issue

2026-10-16 21:13:01 +00:00

[PR #428] [CLOSED] chore(main): release rea-agents 0.4.0 #1977

No milestone

No project

No assignees

1 participant

Notifications

Due date

The due date is invalid or out of range. Please use the format "yyyy-mm-dd".

No due date set.

Dependencies

No dependencies set.

Reference

morluto/rea#428

No description provided.

Rows
Columns