---
read_when:
    - คุณต้องการให้เอเจนต์ OpenClaw ใช้แค็ตตาล็อกเครื่องมือขนาดใหญ่โดยไม่ต้องเพิ่มสคีมาของเครื่องมือทุกตัวลงในพรอมต์
    - คุณต้องการให้เครื่องมือ OpenClaw, เครื่องมือ MCP และเครื่องมือไคลเอนต์ถูกเปิดเผยผ่านพื้นผิวรันไทม์แบบกะทัดรัดเพียงหนึ่งเดียว
    - คุณกำลังนำไปใช้หรือดีบักการค้นหาเครื่องมือสำหรับการรัน OpenClaw
summary: 'การค้นหาเครื่องมือ: ย่อแคตตาล็อกเครื่องมือ OpenClaw ขนาดใหญ่ไว้เบื้องหลังการค้นหา การอธิบาย และการเรียกใช้'
title: ค้นหาเครื่องมือ
x-i18n:
    generated_at: "2026-06-27T18:32:45Z"
    model: gpt-5.5
    postprocess_version: locale-links-v1
    provider: openai
    source_hash: 23b46264bab307bbfdfeb1e358c566d498f3bcf77f187ba05d2ae319e115e1f4
    source_path: tools/tool-search.md
    workflow: 16
---

การค้นหาเครื่องมือเป็นฟีเจอร์ทดลองของรันไทม์เอเจนต์ OpenClaw ฟีเจอร์นี้ให้วิธีที่กระชับหนึ่งเดียวแก่เอเจนต์ในการค้นพบและเรียกใช้แค็ตตาล็อกเครื่องมือขนาดใหญ่ มีประโยชน์เมื่อการรันมีเครื่องมือที่พร้อมใช้งานจำนวนมาก แต่โมเดลมีแนวโน้มจะต้องใช้เพียงไม่กี่รายการเท่านั้น

หน้านี้จัดทำเอกสารเกี่ยวกับการค้นหาเครื่องมือของ OpenClaw ไม่ใช่พื้นผิวการค้นหาเครื่องมือหรือเครื่องมือแบบไดนามิกที่เป็นของ Codex โดยตรง โหมดโค้ดแบบเนทีฟของ Codex, การค้นหาเครื่องมือ, เครื่องมือแบบไดนามิกที่เลื่อนการโหลดไว้, และการเรียกเครื่องมือแบบซ้อน เป็นพื้นผิว Codex harness ที่เสถียร และไม่ขึ้นกับ `tools.toolSearch`

เมื่อเปิดใช้สำหรับการรัน OpenClaw โมเดลจะได้รับเครื่องมือ `tool_search_code` หนึ่งรายการเป็นค่าเริ่มต้น เครื่องมือนั้นรันเนื้อหา JavaScript สั้น ๆ ใน subprocess ของ Node ที่แยกโดดเดี่ยวพร้อมบริดจ์ `openclaw.tools`:

```js
const hits = await openclaw.tools.search("create a GitHub issue");
const tool = await openclaw.tools.describe(hits[0].id);
return await openclaw.tools.call(tool.id, {
  title: "Crash on startup",
  body: "Steps to reproduce...",
});
```

แค็ตตาล็อกสามารถรวมเครื่องมือ OpenClaw, เครื่องมือ Plugin, เครื่องมือ MCP, และเครื่องมือที่ไคลเอนต์จัดเตรียมให้ โมเดลจะไม่เห็นสคีมาแบบเต็มทั้งหมดตั้งแต่ต้น แต่จะค้นหาตัวอธิบายแบบกระชับ อธิบายเครื่องมือที่เลือกหนึ่งรายการเมื่อต้องใช้สคีมาที่แน่นอน และเรียกเครื่องมือนั้นผ่าน OpenClaw

การรัน Codex harness จะไม่ได้รับคอนโทรลการค้นหาเครื่องมือ OpenClaw แบบทดลองเหล่านี้ OpenClaw ส่งความสามารถของผลิตภัณฑ์ไปยัง Codex ในรูปแบบเครื่องมือแบบไดนามิก และ Codex เป็นเจ้าของโหมดโค้ดแบบเนทีฟที่เสถียร, การค้นหาเครื่องมือแบบเนทีฟ, เครื่องมือแบบไดนามิกที่เลื่อนการโหลดไว้, และการเรียกเครื่องมือแบบซ้อน

## วิธีการรันหนึ่งเทิร์น

ในช่วงวางแผน ตัวรันแบบฝังของ OpenClaw จะสร้างแค็ตตาล็อกที่มีผลสำหรับการรัน:

1. แก้ไขนโยบายเครื่องมือที่ใช้งานอยู่สำหรับเอเจนต์ โปรไฟล์ แซนด์บ็อกซ์ และเซสชัน
2. แสดงรายการเครื่องมือ OpenClaw และ Plugin ที่มีสิทธิ์
3. แสดงรายการเครื่องมือ MCP ที่มีสิทธิ์ผ่านรันไทม์ MCP ของเซสชัน
4. เพิ่มเครื่องมือไคลเอนต์ที่มีสิทธิ์ซึ่งจัดเตรียมให้สำหรับการรันปัจจุบัน
5. ทำดัชนีตัวอธิบายแบบกระชับสำหรับการค้นหา
6. เปิดเผยบริดจ์โค้ด OpenClaw, เครื่องมือสำรองแบบมีโครงสร้าง, หรือพื้นผิวไดเรกทอรีแบบกระชับให้กับโมเดล

ในช่วงดำเนินการ การเรียกเครื่องมือจริงทุกครั้งจะกลับมาที่ OpenClaw รันไทม์ Node ที่แยกโดดเดี่ยวไม่ได้ถือการใช้งาน Plugin, อ็อบเจกต์ไคลเอนต์ MCP, หรือความลับไว้ `openclaw.tools.call(...)` ข้ามบริดจ์กลับเข้า Gateway ซึ่งนโยบาย การอนุมัติ hook การบันทึก และการจัดการผลลัพธ์ตามปกติยังคงมีผล

## โหมด

`tools.toolSearch` มีโหมดที่แสดงต่อโมเดลสามแบบ:

- `code`: เปิดเผย `tool_search_code` ซึ่งเป็นบริดจ์ JavaScript แบบกระชับตามค่าเริ่มต้น
- `tools`: เปิดเผย `tool_search`, `tool_describe`, และ `tool_call` เป็นเครื่องมือแบบมีโครงสร้างธรรมดาสำหรับผู้ให้บริการที่ไม่ควรได้รับโค้ด
- `directory`: เปิดเผย `tool_search`, `tool_describe`, และ `tool_call` พร้อมไดเรกทอรีพรอมป์แบบมีขอบเขตของชื่อและคำอธิบายเครื่องมือที่พร้อมใช้งาน สำหรับผู้ให้บริการที่ควรเห็นชื่อเครื่องมือโดยไม่ต้องเห็นสคีมาแบบเต็มทุกรายการ OpenClaw ยังสามารถเปิดเผยชุดสคีมาของเครื่องมือขนาดเล็กแบบมีขอบเขตที่มีแนวโน้มต้องใช้หรือจำเป็นโดยตรงสำหรับเทิร์นปัจจุบัน

ทุกโหมดใช้แค็ตตาล็อกเดียวกันที่ผ่านการกรองตามนโยบาย และเส้นทางการดำเนินการ OpenClaw ตามปกติ หากรันไทม์ปัจจุบันไม่สามารถเปิด subprocess ลูกของ Node สำหรับโหมดโค้ดที่แยกโดดเดี่ยวได้ โหมด `code` ตามค่าเริ่มต้นจะถอยกลับไปเป็น `tools` ก่อนการบีบอัดแค็ตตาล็อก ในโหมด `directory` เครื่องมือที่ไคลเอนต์จัดเตรียมให้จะยังคงมองเห็นได้โดยตรงสำหรับการรันปัจจุบัน ขณะที่เครื่องมือ OpenClaw, เครื่องมือ Plugin, และเครื่องมือ MCP สามารถถูกบีบอัดไว้หลังแค็ตตาล็อกไดเรกทอรีได้ การเรียกโดยตรงไปยังชื่อไดเรกทอรีที่ซ่อนไว้อย่างแน่นอนจะถูกเติมข้อมูลจากแค็ตตาล็อกที่ได้รับอนุญาตเดียวกันนั้นก่อนดำเนินการ

ทุกโหมดเป็นแบบทดลอง ใช้การเปิดเผยเครื่องมือโดยตรงเป็นหลักสำหรับแค็ตตาล็อกเครื่องมือ OpenClaw ขนาดเล็ก และใช้พื้นผิวเสถียรที่เป็นเนทีฟของ Codex เป็นหลักสำหรับการรัน Codex harness

ไม่มีการตั้งค่าเลือกแหล่งที่มาแยกต่างหาก เมื่อเปิดใช้การค้นหาเครื่องมือ แค็ตตาล็อกจะรวมเครื่องมือ OpenClaw, MCP, และไคลเอนต์ที่มีสิทธิ์หลังการกรองตามนโยบายปกติ

## เหตุผลที่มีฟีเจอร์นี้

แค็ตตาล็อกขนาดใหญ่มีประโยชน์แต่มีต้นทุนสูง การส่งสคีมาของเครื่องมือทุกตัวให้โมเดลทำให้คำขอใหญ่ขึ้น ทำให้การวางแผนช้าลง และเพิ่มโอกาสเลือกเครื่องมือโดยไม่ตั้งใจ

การค้นหาเครื่องมือเปลี่ยนรูปแบบดังนี้:

- เครื่องมือโดยตรง: โมเดลเห็นทุกสคีมาที่เลือกก่อนโทเคนแรก
- โหมดโค้ดของการค้นหาเครื่องมือ: โมเดลเห็นเครื่องมือโค้ดแบบกระชับหนึ่งรายการและสัญญา API สั้น ๆ
- โหมดเครื่องมือของการค้นหาเครื่องมือ: โมเดลเห็นเครื่องมือสำรองแบบมีโครงสร้างที่กระชับสามรายการ
- โหมดไดเรกทอรีของการค้นหาเครื่องมือ: โมเดลเห็นไดเรกทอรีแบบมีขอบเขต พร้อมคอนโทรล search/describe/call และชุดสคีมาที่มีแนวโน้มต้องใช้หรือจำเป็นขนาดเล็กแบบมีขอบเขต
- ระหว่างเทิร์น: โมเดลสามารถโหลดสคีมาที่เหลือได้ตามต้องการ

การเปิดเผยเครื่องมือโดยตรงยังคงเป็นค่าเริ่มต้นที่เหมาะสมสำหรับแค็ตตาล็อกขนาดเล็ก การค้นหาเครื่องมือเหมาะที่สุดเมื่อการรันหนึ่งครั้งสามารถเห็นเครื่องมือจำนวนมาก โดยเฉพาะจากเซิร์ฟเวอร์ MCP หรือเครื่องมือแอปที่ไคลเอนต์จัดเตรียมให้

## API

`openclaw.tools.search(query, options?)`

ค้นหาแค็ตตาล็อกที่มีผลสำหรับการรันปัจจุบัน ผลลัพธ์มีขนาดกระชับและปลอดภัยสำหรับใส่กลับเข้าไปในบริบทพรอมป์

```js
const hits = await openclaw.tools.search("calendar event", { limit: 5 });
```

`openclaw.tools.describe(id)`

โหลดเมตาดาทาแบบเต็มสำหรับผลการค้นหาหนึ่งรายการ รวมถึงสคีมาอินพุตที่แน่นอน

```js
const calendarCreate = await openclaw.tools.describe("mcp:calendar:create_event");
```

`openclaw.tools.call(id, args)`

เรียกเครื่องมือที่เลือกผ่าน OpenClaw

```js
await openclaw.tools.call(calendarCreate.id, {
  summary: "Planning",
  start: "2026-05-09T14:00:00Z",
});
```

โหมดสำรองแบบมีโครงสร้างเปิดเผยการดำเนินการเดียวกันเป็นเครื่องมือ:

- `tool_search`
- `tool_describe`
- `tool_call`

โหมดไดเรกทอรีเปิดเผย:

- `tool_search`
- `tool_describe`
- `tool_call`

นอกจากนี้ยังคงให้เครื่องมือที่ไคลเอนต์จัดเตรียมให้มองเห็นได้โดยตรง และอาจเปิดเผยชุดสคีมาของเครื่องมือในแค็ตตาล็อกที่มีแนวโน้มต้องใช้หรือจำเป็นขนาดเล็กแบบมีขอบเขตโดยตรงสำหรับเทิร์นปัจจุบัน หากไดเรกทอรีแบบมีขอบเขตละเว้นรายการไว้ ให้ใช้ `tool_search` เพื่อค้นหา หากโมเดลร้องขอชื่อเครื่องมือในไดเรกทอรีที่ซ่อนไว้อย่างแน่นอนโดยตรง OpenClaw จะเติมข้อมูลจากแค็ตตาล็อกที่ได้รับอนุญาตก่อนการดำเนินการปกติ
ชื่อเครื่องมือไคลเอนต์ในโหมดไดเรกทอรีต้องไม่ชนกับชื่อเครื่องมือ OpenClaw, Plugin, หรือ MCP เพราะการส่งต่อแบบเลื่อนการทำงานที่แน่นอนใช้ชื่อเหล่านั้น

## ขอบเขตรันไทม์

บริดจ์โค้ดรันใน subprocess ของ Node ที่มีอายุสั้น subprocess เริ่มต้นโดยเปิดใช้โหมดสิทธิ์ของ Node พร้อมสภาพแวดล้อมว่าง ไม่มีสิทธิ์ filesystem หรือเครือข่าย และไม่มีสิทธิ์ child-process หรือ worker OpenClaw บังคับใช้ timeout ตามเวลาจริงของโปรเซสแม่ และฆ่า subprocess เมื่อ timeout รวมถึงหลัง continuation แบบ async

รันไทม์เปิดเผยเฉพาะ:

- `console.log`, `console.warn`, และ `console.error`
- `openclaw.tools.search`
- `openclaw.tools.describe`
- `openclaw.tools.call`

พฤติกรรม OpenClaw ตามปกติยังคงใช้กับการเรียกขั้นสุดท้าย:

- นโยบายอนุญาตและปฏิเสธเครื่องมือ
- ข้อจำกัดเครื่องมือต่อเอเจนต์และต่อแซนด์บ็อกซ์
- นโยบายเครื่องมือของช่องทาง/รันไทม์
- hook การอนุมัติ
- hook `before_tool_call` ของ Plugin
- ตัวตนเซสชัน บันทึก และ telemetry

## การกำหนดค่า

เปิดใช้การค้นหาเครื่องมือสำหรับการรัน OpenClaw ด้วยบริดจ์โค้ดตามค่าเริ่มต้น:

```bash
openclaw config set tools.toolSearch true
```

JSON ที่เทียบเท่า:

```json5
{
  tools: {
    toolSearch: true,
  },
}
```

ใช้เครื่องมือสำรองแบบมีโครงสร้างแทนสำหรับการรัน OpenClaw:

```json5
{
  tools: {
    toolSearch: {
      mode: "tools",
    },
  },
}
```

ใช้พื้นผิวไดเรกทอรีแบบกระชับแทนสำหรับการรัน OpenClaw:

```json5
{
  tools: {
    toolSearch: {
      mode: "directory",
    },
  },
}
```

ปรับ timeout ของโหมดโค้ดและขีดจำกัดผลลัพธ์การค้นหา:

```json5
{
  tools: {
    toolSearch: {
      mode: "code",
      codeTimeoutMs: 10000,
      searchDefaultLimit: 8,
      maxSearchLimit: 20,
    },
  },
}
```

ปิดใช้งาน:

```json5
{
  tools: {
    toolSearch: false,
  },
}
```

## พรอมป์และ telemetry

การค้นหาเครื่องมือบันทึก telemetry เพียงพอเพื่อเปรียบเทียบกับการเปิดเผยเครื่องมือโดยตรง:

- จำนวนไบต์เครื่องมือและพรอมป์ที่ซีเรียลไลซ์ทั้งหมดซึ่งส่งไปยัง harness
- ขนาดแค็ตตาล็อกและการแจกแจงตามแหล่งที่มา
- จำนวนการค้นหา การอธิบาย และการเรียก
- การเรียกเครื่องมือขั้นสุดท้ายที่ดำเนินการผ่าน OpenClaw
- ids และแหล่งที่มาของเครื่องมือที่เลือก

บันทึกเซสชันควรทำให้ตอบคำถามต่อไปนี้ได้:

- โมเดลเห็นสคีมาของเครื่องมือกี่รายการตั้งแต่ต้น
- โมเดลดำเนินการค้นหาและอธิบายกี่ครั้ง
- เครื่องมือขั้นสุดท้ายใดถูกเรียก
- ผลลัพธ์มาจาก OpenClaw, MCP, หรือเครื่องมือไคลเอนต์

## การตรวจสอบ E2E

ตัวรัน E2E ของ Gateway พิสูจน์ทั้งสองเส้นทางด้วยรันไทม์ OpenClaw:

```bash
node --import tsx scripts/tool-search-gateway-e2e.ts
```

ตัวรันสร้าง Plugin ปลอมชั่วคราวที่มีแค็ตตาล็อกเครื่องมือขนาดใหญ่ เริ่มผู้ให้บริการ OpenAI จำลอง เริ่ม Gateway หนึ่งครั้งในโหมดโดยตรงและอีกครั้งโดยเปิดใช้การค้นหาเครื่องมือ จากนั้นเปรียบเทียบเพย์โหลดคำขอของผู้ให้บริการและบันทึกเซสชัน

รีเกรสชันพิสูจน์ว่า:

1. โหมดโดยตรงสามารถเรียกเครื่องมือ Plugin ปลอมได้
2. การค้นหาเครื่องมือสามารถเรียกเครื่องมือ Plugin ปลอมเดียวกันได้
3. โหมดโดยตรงเปิดเผยสคีมาของเครื่องมือ Plugin ปลอมให้ผู้ให้บริการโดยตรง
4. การค้นหาเครื่องมือเปิดเผยเฉพาะบริดจ์แบบกระชับ
5. เพย์โหลดคำขอของการค้นหาเครื่องมือมีขนาดเล็กกว่าสำหรับแค็ตตาล็อกปลอมขนาดใหญ่
6. บันทึกเซสชันแสดงจำนวนการเรียกเครื่องมือที่คาดไว้และ telemetry ของการเรียกผ่านบริดจ์

## พฤติกรรมเมื่อเกิดความล้มเหลว

การค้นหาเครื่องมือควรล้มเหลวแบบปิด:

- หากเครื่องมือไม่อยู่ในนโยบายที่มีผล การค้นหาไม่ควรส่งคืนเครื่องมือนั้น
- หากเครื่องมือที่เลือกไม่พร้อมใช้งาน `tool_call` ควรล้มเหลว
- หากนโยบายหรือการอนุมัติบล็อกการดำเนินการ ผลลัพธ์การเรียกควรรายงานการบล็อกนั้นแทนการข้ามไป
- หากบริดจ์โค้ดไม่สามารถสร้างรันไทม์ที่แยกโดดเดี่ยวได้ ให้ใช้ `mode: "tools"` หรือปิดใช้การค้นหาเครื่องมือสำหรับการปรับใช้นั้น

## ที่เกี่ยวข้อง

- [เครื่องมือและ Plugin](/th/tools)
- [แซนด์บ็อกซ์และเครื่องมือแบบหลายเอเจนต์](/th/tools/multi-agent-sandbox-tools)
- [เครื่องมือ Exec](/th/tools/exec)
- [การตั้งค่าเอเจนต์ ACP](/th/tools/acp-agents-setup)
- [การสร้าง Plugin](/th/plugins/building-plugins)