dynamic tools, and nested tool calls are stable Codex harness surfaces and do

not depend on `tools.toolSearch`.

When enabled for OpenClaw runs, the model receives one `tool_search_code` tool by default.

That tool runs a short JavaScript body in an isolated Node subprocess with an

`openclaw.tools` bridge:

When enabled for OpenClaw runs, the model receives one `tool_search_code` tool

by default. That tool runs a short JavaScript body in an isolated Node

subprocess with an `openclaw.tools` bridge:

```js

const hits = await openclaw.tools.search("create a GitHub issue");

3. List eligible MCP tools through the session MCP runtime.

4. Add eligible client tools supplied for the current run.

5. Index compact descriptors for search.

6. Expose either the OpenClaw code bridge or the structured fallback tools to the

model.

6. Expose the OpenClaw code bridge, the structured fallback tools, or the

compact directory surface to the model.

At execution time every real tool call returns to OpenClaw. The isolated Node

runtime does not hold plugin implementations, MCP client objects, or secrets.

## Modes

`tools.toolSearch` has two model-facing modes:

`tools.toolSearch` has three model-facing modes:

- `code`: exposes `tool_search_code`, the default compact JavaScript bridge.

- `tools`: exposes `tool_search`, `tool_describe`, and `tool_call` as plain

structured tools for providers that should not receive code.

Both modes use the same catalog and execution path. The only difference is the

shape the model sees. If the current runtime cannot launch the isolated Node

code-mode child process, the default `code` mode falls back to `tools` before

catalog compaction.

Both modes are experimental. Prefer direct tool exposure for small OpenClaw tool

- `directory`: exposes `tool_search`, `tool_describe`, and `tool_call` plus a

bounded prompt directory of available tool names and descriptions for

providers that should see tool names without every full schema. OpenClaw can

also expose a small bounded set of likely or required tool schemas directly

for the current turn.

All modes use the same policy-filtered catalog and normal OpenClaw execution

path. If the current runtime cannot launch the isolated Node code-mode child

process, the default `code` mode falls back to `tools` before catalog

compaction. In `directory` mode, client-provided tools stay directly visible

for the current run while OpenClaw tools, plugin tools, and MCP tools can be

compacted behind the directory catalog. A direct call to an exact hidden

directory name is hydrated from that same authorized catalog before execution.

All modes are experimental. Prefer direct tool exposure for small OpenClaw tool

catalogs, and prefer the Codex-native stable surfaces for Codex harness runs.

There is no separate source-selection config. When Tool Search is enabled, the

contract

- Tool Search tools mode: the model sees three compact structured fallback

tools

- during the turn: the model loads only the tool schemas it actually needs

- Tool Search directory mode: the model sees a bounded directory plus

search/describe/call controls and a small bounded set of likely or required

schemas

- during the turn: the model can load remaining schemas as needed

Direct tool exposure is still the right default for small catalogs. Tool Search

is best when one run can see many tools, especially from MCP servers or

- `tool_describe`

- `tool_call`

Directory mode exposes:

- `tool_search`

- `tool_describe`

- `tool_call`

It also keeps client-provided tools directly visible and may expose a small

bounded set of likely or required catalog tool schemas directly for the current

turn. If the bounded directory omits entries, use `tool_search` to find them. If

the model requests an exact hidden directory tool name directly, OpenClaw

hydrates it from the authorized catalog before normal execution.

Directory-mode client tool names must not collide with OpenClaw, plugin, or MCP

tool names because exact deferred dispatch uses those names.

## Runtime boundary

The code bridge runs in a short-lived Node subprocess. The subprocess starts

}

```

Use the compact directory surface instead for OpenClaw runs:

```json5

{

tools: {

toolSearch: {

mode: "directory",

},

},

}

```

Tune code-mode timeout and search result limits:

```json5