---
read_when:
    - คุณกำลังสร้าง Plugin ผู้ให้บริการโมเดลใหม่
    - คุณต้องการเพิ่มพร็อกซีที่เข้ากันได้กับ OpenAI หรือโมเดลภาษาขนาดใหญ่แบบกำหนดเองลงใน OpenClaw
    - คุณต้องเข้าใจการยืนยันตัวตนของผู้ให้บริการ แคตตาล็อก และฮุกรันไทม์
sidebarTitle: Provider plugins
summary: คู่มือทีละขั้นตอนสำหรับการสร้าง Plugin ผู้ให้บริการโมเดลสำหรับ OpenClaw
title: การสร้าง Plugin สำหรับผู้ให้บริการ
x-i18n:
    generated_at: "2026-05-02T22:21:51Z"
    model: gpt-5.5
    provider: openai
    source_hash: f7cca1dcf2f0a34fd05c696149fef42ff8fecf1ca1fe0ccc63ba96212a9889fe
    source_path: plugins/sdk-provider-plugins.md
    workflow: 16
---

คู่มือนี้อธิบายขั้นตอนการสร้าง Plugin ผู้ให้บริการที่เพิ่มผู้ให้บริการโมเดล
(LLM) ให้กับ OpenClaw เมื่อจบแล้ว คุณจะมีผู้ให้บริการพร้อมแค็ตตาล็อกโมเดล,
การยืนยันตัวตนด้วย API key และการระบุโมเดลแบบไดนามิก

<Info>
  หากคุณยังไม่เคยสร้าง OpenClaw Plugin มาก่อน ให้อ่าน
  [เริ่มต้นใช้งาน](/th/plugins/building-plugins) ก่อน เพื่อดูโครงสร้างแพ็กเกจพื้นฐาน
  และการตั้งค่า manifest
</Info>

<Tip>
  Provider plugins เพิ่มโมเดลเข้าสู่ลูป inference ปกติของ OpenClaw หากโมเดล
  ต้องทำงานผ่าน native agent daemon ที่เป็นเจ้าของเธรด, compaction หรือเหตุการณ์ของเครื่องมือ
  ให้จับคู่ผู้ให้บริการกับ [agent harness](/th/plugins/sdk-agent-harness)
  แทนการใส่รายละเอียดโปรโตคอลของ daemon ไว้ใน core
</Tip>

## บทแนะนำแบบทีละขั้นตอน

<Steps>
  <Step title="แพ็กเกจและ manifest">
    ### ขั้นตอนที่ 1: แพ็กเกจและ manifest

    <CodeGroup>
    ```json package.json
    {
      "name": "@myorg/openclaw-acme-ai",
      "version": "1.0.0",
      "type": "module",
      "openclaw": {
        "extensions": ["./index.ts"],
        "providers": ["acme-ai"],
        "compat": {
          "pluginApi": ">=2026.3.24-beta.2",
          "minGatewayVersion": "2026.3.24-beta.2"
        },
        "build": {
          "openclawVersion": "2026.3.24-beta.2",
          "pluginSdkVersion": "2026.3.24-beta.2"
        }
      }
    }
    ```

    ```json openclaw.plugin.json
    {
      "id": "acme-ai",
      "name": "Acme AI",
      "description": "Acme AI model provider",
      "providers": ["acme-ai"],
      "modelSupport": {
        "modelPrefixes": ["acme-"]
      },
      "providerAuthEnvVars": {
        "acme-ai": ["ACME_AI_API_KEY"]
      },
      "providerAuthAliases": {
        "acme-ai-coding": "acme-ai"
      },
      "providerAuthChoices": [
        {
          "provider": "acme-ai",
          "method": "api-key",
          "choiceId": "acme-ai-api-key",
          "choiceLabel": "Acme AI API key",
          "groupId": "acme-ai",
          "groupLabel": "Acme AI",
          "cliFlag": "--acme-ai-api-key",
          "cliOption": "--acme-ai-api-key <key>",
          "cliDescription": "Acme AI API key"
        }
      ],
      "configSchema": {
        "type": "object",
        "additionalProperties": false
      }
    }
    ```
    </CodeGroup>

    manifest ประกาศ `providerAuthEnvVars` เพื่อให้ OpenClaw ตรวจพบ
    ข้อมูลรับรองได้โดยไม่ต้องโหลด runtime ของ Plugin เพิ่ม `providerAuthAliases`
    เมื่อ variant ของผู้ให้บริการควรใช้ auth ของ provider id อื่นซ้ำ `modelSupport`
    เป็นตัวเลือกเสริม และช่วยให้ OpenClaw โหลด Provider Plugin ของคุณโดยอัตโนมัติจาก
    model id แบบย่อ เช่น `acme-large` ก่อนที่จะมี runtime hooks หากคุณเผยแพร่
    ผู้ให้บริการบน ClawHub ฟิลด์ `openclaw.compat` และ `openclaw.build` เหล่านั้น
    จำเป็นต้องมีใน `package.json`

  </Step>

  <Step title="ลงทะเบียนผู้ให้บริการ">
    ผู้ให้บริการขั้นต่ำต้องมี `id`, `label`, `auth` และ `catalog`:

    ```typescript index.ts
    import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
    import { createProviderApiKeyAuthMethod } from "openclaw/plugin-sdk/provider-auth";

    export default definePluginEntry({
      id: "acme-ai",
      name: "Acme AI",
      description: "Acme AI model provider",
      register(api) {
        api.registerProvider({
          id: "acme-ai",
          label: "Acme AI",
          docsPath: "/providers/acme-ai",
          envVars: ["ACME_AI_API_KEY"],

          auth: [
            createProviderApiKeyAuthMethod({
              providerId: "acme-ai",
              methodId: "api-key",
              label: "Acme AI API key",
              hint: "API key from your Acme AI dashboard",
              optionKey: "acmeAiApiKey",
              flagName: "--acme-ai-api-key",
              envVar: "ACME_AI_API_KEY",
              promptMessage: "Enter your Acme AI API key",
              defaultModel: "acme-ai/acme-large",
            }),
          ],

          catalog: {
            order: "simple",
            run: async (ctx) => {
              const apiKey =
                ctx.resolveProviderApiKey("acme-ai").apiKey;
              if (!apiKey) return null;
              return {
                provider: {
                  baseUrl: "https://api.acme-ai.com/v1",
                  apiKey,
                  api: "openai-completions",
                  models: [
                    {
                      id: "acme-large",
                      name: "Acme Large",
                      reasoning: true,
                      input: ["text", "image"],
                      cost: { input: 3, output: 15, cacheRead: 0.3, cacheWrite: 3.75 },
                      contextWindow: 200000,
                      maxTokens: 32768,
                    },
                    {
                      id: "acme-small",
                      name: "Acme Small",
                      reasoning: false,
                      input: ["text"],
                      cost: { input: 1, output: 5, cacheRead: 0.1, cacheWrite: 1.25 },
                      contextWindow: 128000,
                      maxTokens: 8192,
                    },
                  ],
                },
              };
            },
          },
        });
      },
    });
    ```

    นี่คือผู้ให้บริการที่ใช้งานได้แล้ว ผู้ใช้สามารถ
    `openclaw onboard --acme-ai-api-key <key>` และเลือก
    `acme-ai/acme-large` เป็นโมเดลของตนได้

    หากผู้ให้บริการต้นทางใช้ control tokens ต่างจาก OpenClaw ให้เพิ่ม
    การแปลงข้อความสองทิศทางขนาดเล็กแทนการแทนที่เส้นทางสตรีม:

    ```typescript
    api.registerTextTransforms({
      input: [
        { from: /red basket/g, to: "blue basket" },
        { from: /paper ticket/g, to: "digital ticket" },
        { from: /left shelf/g, to: "right shelf" },
      ],
      output: [
        { from: /blue basket/g, to: "red basket" },
        { from: /digital ticket/g, to: "paper ticket" },
        { from: /right shelf/g, to: "left shelf" },
      ],
    });
    ```

    `input` เขียน prompt ระบบสุดท้ายและเนื้อหาข้อความใหม่ก่อน
    การส่งผ่าน transport ส่วน `output` เขียน assistant text deltas และข้อความสุดท้ายใหม่ก่อนที่
    OpenClaw จะแยกวิเคราะห์ control markers หรือการส่งมอบผ่านช่องทางของตนเอง

    สำหรับผู้ให้บริการแบบ bundled ที่ลงทะเบียน text provider เพียงหนึ่งรายการพร้อม auth แบบ API-key
    และ runtime ที่อิงแค็ตตาล็อกเพียงรายการเดียว ให้เลือกใช้ helper ที่แคบกว่า
    `defineSingleProviderPluginEntry(...)`:

    ```typescript
    import { defineSingleProviderPluginEntry } from "openclaw/plugin-sdk/provider-entry";

    export default defineSingleProviderPluginEntry({
      id: "acme-ai",
      name: "Acme AI",
      description: "Acme AI model provider",
      provider: {
        label: "Acme AI",
        docsPath: "/providers/acme-ai",
        auth: [
          {
            methodId: "api-key",
            label: "Acme AI API key",
            hint: "API key from your Acme AI dashboard",
            optionKey: "acmeAiApiKey",
            flagName: "--acme-ai-api-key",
            envVar: "ACME_AI_API_KEY",
            promptMessage: "Enter your Acme AI API key",
            defaultModel: "acme-ai/acme-large",
          },
        ],
        catalog: {
          buildProvider: () => ({
            api: "openai-completions",
            baseUrl: "https://api.acme-ai.com/v1",
            models: [{ id: "acme-large", name: "Acme Large" }],
          }),
          buildStaticProvider: () => ({
            api: "openai-completions",
            baseUrl: "https://api.acme-ai.com/v1",
            models: [{ id: "acme-large", name: "Acme Large" }],
          }),
        },
      },
    });
    ```

    `buildProvider` คือเส้นทางแค็ตตาล็อกสดที่ใช้เมื่อ OpenClaw สามารถระบุ auth จริง
    ของผู้ให้บริการได้ อาจทำ discovery เฉพาะผู้ให้บริการ ใช้
    `buildStaticProvider` เฉพาะสำหรับแถวแบบออฟไลน์ที่ปลอดภัยให้แสดงก่อนตั้งค่า auth
    เท่านั้น; ต้องไม่ต้องใช้ข้อมูลรับรองหรือส่งคำขอเครือข่าย
    การแสดงผล `models list --all` ของ OpenClaw ในปัจจุบันเรียกใช้ static catalogs
    เฉพาะสำหรับ Provider Plugins แบบ bundled โดยใช้ config ว่าง, env ว่าง และไม่มี
    พาธ agent/workspace

    หาก flow auth ของคุณยังต้อง patch `models.providers.*`, aliases และ
    โมเดลเริ่มต้นของ agent ระหว่าง onboarding ให้ใช้ preset helpers จาก
    `openclaw/plugin-sdk/provider-onboard` helpers ที่แคบที่สุดคือ
    `createDefaultModelPresetAppliers(...)`,
    `createDefaultModelsPresetAppliers(...)` และ
    `createModelCatalogPresetAppliers(...)`

    เมื่อ native endpoint ของผู้ให้บริการรองรับ streamed usage blocks บน
    transport `openai-completions` ปกติ ให้เลือกใช้ catalog helpers ที่ใช้ร่วมกันใน
    `openclaw/plugin-sdk/provider-catalog-shared` แทนการ hardcode
    การตรวจสอบ provider-id `supportsNativeStreamingUsageCompat(...)` และ
    `applyProviderNativeStreamingUsageCompat(...)` ตรวจพบการรองรับจาก
    endpoint capability map ดังนั้น endpoint แบบ native Moonshot/DashScope-style จึงยัง
    opt in ได้แม้ Plugin จะใช้ provider id แบบกำหนดเอง

  </Step>

  <Step title="เพิ่มการระบุโมเดลแบบไดนามิก">
    หากผู้ให้บริการของคุณรับ model IDs ตามอำเภอใจ (เช่น proxy หรือ router)
    ให้เพิ่ม `resolveDynamicModel`:

    ```typescript
    api.registerProvider({
      // ... id, label, auth, catalog from above

      resolveDynamicModel: (ctx) => ({
        id: ctx.modelId,
        name: ctx.modelId,
        provider: "acme-ai",
        api: "openai-completions",
        baseUrl: "https://api.acme-ai.com/v1",
        reasoning: false,
        input: ["text"],
        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
        contextWindow: 128000,
        maxTokens: 8192,
      }),
    });
    ```

    หากการระบุต้องใช้การเรียกเครือข่าย ให้ใช้ `prepareDynamicModel` สำหรับ async
    warm-up — `resolveDynamicModel` จะทำงานอีกครั้งหลังจากเสร็จสิ้น

  </Step>

  <Step title="เพิ่ม runtime hooks (ตามต้องการ)">
    ผู้ให้บริการส่วนใหญ่ต้องใช้เพียง `catalog` + `resolveDynamicModel` เพิ่ม hooks
    ทีละส่วนตามที่ผู้ให้บริการของคุณต้องการ

    ตอนนี้ shared helper builders ครอบคลุมกลุ่ม replay/tool-compat ที่พบบ่อยที่สุดแล้ว
    ดังนั้นโดยปกติ Plugins ไม่จำเป็นต้องเชื่อมแต่ละ hook ด้วยตนเองทีละรายการ:

    ```typescript
    import { buildProviderReplayFamilyHooks } from "openclaw/plugin-sdk/provider-model-shared";
    import { buildProviderStreamFamilyHooks } from "openclaw/plugin-sdk/provider-stream";
    import { buildProviderToolCompatFamilyHooks } from "openclaw/plugin-sdk/provider-tools";

    const GOOGLE_FAMILY_HOOKS = {
      ...buildProviderReplayFamilyHooks({ family: "google-gemini" }),
      ...buildProviderStreamFamilyHooks("google-thinking"),
      ...buildProviderToolCompatFamilyHooks("gemini"),
    };

    api.registerProvider({
      id: "acme-gemini-compatible",
      // ...
      ...GOOGLE_FAMILY_HOOKS,
    });
    ```

    กลุ่ม replay ที่มีในวันนี้:

    | กลุ่ม | สิ่งที่เชื่อมให้ | ตัวอย่างแบบ bundled |
    | --- | --- | --- |
    | `openai-compatible` | นโยบาย replay แบบ OpenAI-style ที่ใช้ร่วมกันสำหรับ transports ที่เข้ากันได้กับ OpenAI รวมถึงการทำความสะอาด tool-call-id, การแก้ลำดับ assistant-first และการตรวจสอบ Gemini-turn ทั่วไปเมื่อ transport ต้องใช้ | `moonshot`, `ollama`, `xai`, `zai` |
    | `anthropic-by-model` | นโยบาย replay ที่เข้าใจ Claude ซึ่งเลือกตาม `modelId` เพื่อให้ transports แบบ Anthropic-message ได้รับการล้าง thinking-block เฉพาะ Claude ต่อเมื่อโมเดลที่ระบุได้เป็น Claude id จริงเท่านั้น | `amazon-bedrock`, `anthropic-vertex` |
    | `google-gemini` | นโยบาย replay ของ native Gemini พร้อม bootstrap replay sanitation และโหมด tagged reasoning-output | `google`, `google-gemini-cli` |
    | `passthrough-gemini` | การทำความสะอาด Gemini thought-signature สำหรับโมเดล Gemini ที่ทำงานผ่าน transports แบบ proxy ที่เข้ากันได้กับ OpenAI; ไม่เปิดใช้การตรวจสอบ native Gemini replay หรือ bootstrap rewrites | `openrouter`, `kilocode`, `opencode`, `opencode-go` |
    | `hybrid-anthropic-openai` | นโยบาย hybrid สำหรับผู้ให้บริการที่ผสมพื้นผิวโมเดลแบบ Anthropic-message และ OpenAI-compatible ใน Plugin เดียว; การ drop thinking-block เฉพาะ Claude แบบตัวเลือกเสริมจะยังจำกัดอยู่ที่ฝั่ง Anthropic | `minimax` |

    กลุ่มสตรีมที่มีในวันนี้:

    | กลุ่ม | สิ่งที่เชื่อมเข้าไป | ตัวอย่างที่รวมมาให้ |
    | --- | --- | --- |
    | `google-thinking` | การทำให้ thinking payload ของ Gemini อยู่ในรูปแบบปกติบนเส้นทางสตรีมที่ใช้ร่วมกัน | `google`, `google-gemini-cli` |
    | `kilocode-thinking` | wrapper การให้เหตุผลของ Kilo บนเส้นทางสตรีมพร็อกซีที่ใช้ร่วมกัน โดยข้ามการฉีด thinking สำหรับ `kilo/auto` และ id การให้เหตุผลของพร็อกซีที่ไม่รองรับ | `kilocode` |
    | `moonshot-thinking` | การแมป payload native-thinking แบบไบนารีของ Moonshot จาก config + ระดับ `/think` | `moonshot` |
    | `minimax-fast-mode` | การเขียน model ใหม่สำหรับโหมดเร็วของ MiniMax บนเส้นทางสตรีมที่ใช้ร่วมกัน | `minimax`, `minimax-portal` |
    | `openai-responses-defaults` | wrapper Responses แบบ native ของ OpenAI/Codex ที่ใช้ร่วมกัน: header การระบุที่มา, `/fast`/`serviceTier`, ความละเอียดของข้อความ, การค้นเว็บ native ของ Codex, การปรับรูป payload ให้เข้ากันได้กับ reasoning และการจัดการ context ของ Responses | `openai`, `openai-codex` |
    | `openrouter-thinking` | wrapper การให้เหตุผลของ OpenRouter สำหรับ route พร็อกซี โดยจัดการการข้าม model ที่ไม่รองรับ/`auto` จากส่วนกลาง | `openrouter` |
    | `tool-stream-default-on` | wrapper `tool_stream` ที่เปิดโดยค่าเริ่มต้นสำหรับ provider อย่าง Z.AI ที่ต้องการการสตรีม tool เว้นแต่จะปิดไว้อย่างชัดเจน | `zai` |

    <Accordion title="SDK seam ที่ขับเคลื่อนตัวสร้างกลุ่ม">
      ตัวสร้างแต่ละกลุ่มประกอบจาก helper สาธารณะระดับต่ำกว่าที่ export จากแพ็กเกจเดียวกัน ซึ่งคุณสามารถเลือกใช้ได้เมื่อ provider ต้องออกนอกแพตเทิร์นร่วม:

      - `openclaw/plugin-sdk/provider-model-shared` — `ProviderReplayFamily`, `buildProviderReplayFamilyHooks(...)` และตัวสร้าง replay ดิบ (`buildOpenAICompatibleReplayPolicy`, `buildAnthropicReplayPolicyForModel`, `buildGoogleGeminiReplayPolicy`, `buildHybridAnthropicOrOpenAIReplayPolicy`) นอกจากนี้ยัง export helper replay ของ Gemini (`sanitizeGoogleGeminiReplayHistory`, `resolveTaggedReasoningOutputMode`) และ helper endpoint/model (`resolveProviderEndpoint`, `normalizeProviderId`, `normalizeGooglePreviewModelId`, `normalizeNativeXaiModelId`)
      - `openclaw/plugin-sdk/provider-stream` — `ProviderStreamFamily`, `buildProviderStreamFamilyHooks(...)`, `composeProviderStreamWrappers(...)` รวมถึง wrapper OpenAI/Codex ที่ใช้ร่วมกัน (`createOpenAIAttributionHeadersWrapper`, `createOpenAIFastModeWrapper`, `createOpenAIServiceTierWrapper`, `createOpenAIResponsesContextManagementWrapper`, `createCodexNativeWebSearchWrapper`), wrapper DeepSeek V4 ที่เข้ากันได้กับ OpenAI (`createDeepSeekV4OpenAICompatibleThinkingWrapper`), การล้าง thinking prefill ของ Anthropic Messages (`createAnthropicThinkingPrefillPayloadWrapper`) และ wrapper proxy/provider ที่ใช้ร่วมกัน (`createOpenRouterWrapper`, `createToolStreamWrapper`, `createMinimaxFastModeWrapper`)
      - `openclaw/plugin-sdk/provider-tools` — `ProviderToolCompatFamily`, `buildProviderToolCompatFamilyHooks("gemini")`, helper schema ของ Gemini ที่อยู่ข้างใต้ (`normalizeGeminiToolSchemas`, `inspectGeminiToolSchemas`) และ helper compat ของ xAI (`resolveXaiModelCompatPatch()`, `applyXaiModelCompat(model)`) Plugin xAI ที่รวมมาใช้ `normalizeResolvedModel` + `contributeResolvedModelCompat` ร่วมกับสิ่งเหล่านี้เพื่อให้กฎของ xAI อยู่ภายใต้ความเป็นเจ้าของของ provider

      helper สตรีมบางตัวถูกตั้งใจให้คงอยู่ใน provider-local `@openclaw/anthropic-provider` เก็บ `wrapAnthropicProviderStream`, `resolveAnthropicBetas`, `resolveAnthropicFastMode`, `resolveAnthropicServiceTier` และตัวสร้าง wrapper Anthropic ระดับต่ำกว่าไว้ใน seam สาธารณะ `api.ts` / `contract-api.ts` ของตัวเอง เพราะสิ่งเหล่านี้เข้ารหัสการจัดการ Claude OAuth beta และ gating ของ `context1m` Plugin xAI ก็เก็บการปรับรูป Responses native ของ xAI ไว้ใน `wrapStreamFn` ของตัวเองเช่นกัน (alias `/fast`, ค่าเริ่มต้น `tool_stream`, การล้าง strict-tool ที่ไม่รองรับ, การลบ reasoning-payload เฉพาะ xAI)

      แพตเทิร์น package-root เดียวกันยังรองรับ `@openclaw/openai-provider` (ตัวสร้าง provider, helper default-model, ตัวสร้าง realtime provider) และ `@openclaw/openrouter-provider` (ตัวสร้าง provider พร้อม helper onboarding/config)
    </Accordion>

    <Tabs>
      <Tab title="การแลกเปลี่ยน token">
        สำหรับ provider ที่ต้องแลกเปลี่ยน token ก่อนการเรียก inference แต่ละครั้ง:

        ```typescript
        prepareRuntimeAuth: async (ctx) => {
          const exchanged = await exchangeToken(ctx.apiKey);
          return {
            apiKey: exchanged.token,
            baseUrl: exchanged.baseUrl,
            expiresAt: exchanged.expiresAt,
          };
        },
        ```
      </Tab>
      <Tab title="header แบบกำหนดเอง">
        สำหรับ provider ที่ต้องใช้ header คำขอแบบกำหนดเองหรือการแก้ไข body:

        ```typescript
        // wrapStreamFn returns a StreamFn derived from ctx.streamFn
        wrapStreamFn: (ctx) => {
          if (!ctx.streamFn) return undefined;
          const inner = ctx.streamFn;
          return async (params) => {
            params.headers = {
              ...params.headers,
              "X-Acme-Version": "2",
            };
            return inner(params);
          };
        },
        ```
      </Tab>
      <Tab title="ตัวตนของ transport แบบ native">
        สำหรับ provider ที่ต้องใช้ header หรือ metadata ของคำขอ/session แบบ native บน
        transport HTTP หรือ WebSocket ทั่วไป:

        ```typescript
        resolveTransportTurnState: (ctx) => ({
          headers: {
            "x-request-id": ctx.turnId,
          },
          metadata: {
            session_id: ctx.sessionId ?? "",
            turn_id: ctx.turnId,
          },
        }),
        resolveWebSocketSessionPolicy: (ctx) => ({
          headers: {
            "x-session-id": ctx.sessionId ?? "",
          },
          degradeCooldownMs: 60_000,
        }),
        ```
      </Tab>
      <Tab title="การใช้งานและการเรียกเก็บเงิน">
        สำหรับ provider ที่เปิดเผยข้อมูลการใช้งาน/การเรียกเก็บเงิน:

        ```typescript
        resolveUsageAuth: async (ctx) => {
          const auth = await ctx.resolveOAuthToken();
          return auth ? { token: auth.token } : null;
        },
        fetchUsageSnapshot: async (ctx) => {
          return await fetchAcmeUsage(ctx.token, ctx.timeoutMs);
        },
        ```
      </Tab>
    </Tabs>

    <Accordion title="hook ของ provider ทั้งหมดที่มี">
      OpenClaw เรียก hook ตามลำดับนี้ provider ส่วนใหญ่ใช้เพียง 2-3 ตัว:
      field ของ provider ที่มีไว้เพื่อความเข้ากันได้เท่านั้นและ OpenClaw ไม่เรียกแล้ว เช่น
      `ProviderPlugin.capabilities` และ `suppressBuiltInModel` จะไม่ถูกแสดง
      ที่นี่

      | # | Hook | ใช้เมื่อใด |
      | --- | --- | --- |
      | 1 | `catalog` | catalog ของ model หรือค่าเริ่มต้น URL ฐาน |
      | 2 | `applyConfigDefaults` | ค่าเริ่มต้น global ที่ provider เป็นเจ้าของระหว่างการ materialize config |
      | 3 | `normalizeModelId` | การล้าง alias ของ model-id legacy/preview ก่อน lookup |
      | 4 | `normalizeTransport` | การล้าง `api` / `baseUrl` ของกลุ่ม provider ก่อนประกอบ model ทั่วไป |
      | 5 | `normalizeConfig` | ทำให้ config `models.providers.<id>` อยู่ในรูปแบบปกติ |
      | 6 | `applyNativeStreamingUsageCompat` | การเขียน compat ของ native streaming-usage ใหม่สำหรับ provider ใน config |
      | 7 | `resolveConfigApiKey` | การ resolve auth จาก env-marker ที่ provider เป็นเจ้าของ |
      | 8 | `resolveSyntheticAuth` | auth สังเคราะห์แบบ local/self-hosted หรือมี config หนุนหลัง |
      | 9 | `shouldDeferSyntheticProfileAuth` | ลดลำดับความสำคัญ placeholder ของ stored-profile สังเคราะห์ไว้หลัง auth จาก env/config |
      | 10 | `resolveDynamicModel` | ยอมรับ ID model upstream ใดก็ได้ |
      | 11 | `prepareDynamicModel` | ดึง metadata แบบ async ก่อน resolve |
      | 12 | `normalizeResolvedModel` | เขียน transport ใหม่ก่อน runner |
      | 13 | `contributeResolvedModelCompat` | flag compat สำหรับ model ของ vendor ที่อยู่หลัง transport ที่เข้ากันได้อีกชั้น |
      | 14 | `normalizeToolSchemas` | การล้าง tool-schema ที่ provider เป็นเจ้าของก่อนลงทะเบียน |
      | 15 | `inspectToolSchemas` | diagnostic ของ tool-schema ที่ provider เป็นเจ้าของ |
      | 16 | `resolveReasoningOutputMode` | contract ของ reasoning-output แบบ tagged เทียบกับ native |
      | 17 | `prepareExtraParams` | พารามิเตอร์คำขอเริ่มต้น |
      | 18 | `createStreamFn` | transport StreamFn แบบกำหนดเองทั้งหมด |
      | 19 | `wrapStreamFn` | wrapper header/body แบบกำหนดเองบนเส้นทางสตรีมปกติ |
      | 20 | `resolveTransportTurnState` | header/metadata แบบ native ต่อ turn |
      | 21 | `resolveWebSocketSessionPolicy` | header/cool-down ของ session WS แบบ native |
      | 22 | `formatApiKey` | รูปทรง token runtime แบบกำหนดเอง |
      | 23 | `refreshOAuth` | การ refresh OAuth แบบกำหนดเอง |
      | 24 | `buildAuthDoctorHint` | คำแนะนำการซ่อมแซม auth |
      | 25 | `matchesContextOverflowError` | การตรวจจับ overflow ที่ provider เป็นเจ้าของ |
      | 26 | `classifyFailoverReason` | การจัดประเภท rate-limit/overload ที่ provider เป็นเจ้าของ |
      | 27 | `isCacheTtlEligible` | gating TTL ของ prompt cache |
      | 28 | `buildMissingAuthMessage` | hint เมื่อ auth ขาดหายแบบกำหนดเอง |
      | 29 | `augmentModelCatalog` | แถว forward-compat สังเคราะห์ |
      | 30 | `resolveThinkingProfile` | ชุดตัวเลือก `/think` เฉพาะ model |
      | 31 | `isBinaryThinking` | ความเข้ากันได้ของการเปิด/ปิด binary thinking |
      | 32 | `supportsXHighThinking` | ความเข้ากันได้ของการรองรับ reasoning `xhigh` |
      | 33 | `resolveDefaultThinkingLevel` | ความเข้ากันได้ของนโยบาย `/think` เริ่มต้น |
      | 34 | `isModernModelRef` | การจับคู่ model สำหรับ live/smoke |
      | 35 | `prepareRuntimeAuth` | การแลกเปลี่ยน token ก่อน inference |
      | 36 | `resolveUsageAuth` | การแยก credential การใช้งานแบบกำหนดเอง |
      | 37 | `fetchUsageSnapshot` | endpoint การใช้งานแบบกำหนดเอง |
      | 38 | `createEmbeddingProvider` | adapter embedding ที่ provider เป็นเจ้าของสำหรับ memory/search |
      | 39 | `buildReplayPolicy` | นโยบาย replay/compaction ของ transcript แบบกำหนดเอง |
      | 40 | `sanitizeReplayHistory` | การเขียน replay ใหม่เฉพาะ provider หลังการล้างทั่วไป |
      | 41 | `validateReplayTurns` | การตรวจสอบ replay-turn แบบเข้มงวดก่อน runner แบบฝัง |
      | 42 | `onModelSelected` | callback หลังเลือกแล้ว (เช่น telemetry) |

      หมายเหตุ fallback ตอน runtime:

      - `normalizeConfig` ตรวจ provider ที่ตรงกันก่อน จากนั้นตรวจ Plugin ของ provider อื่นที่รองรับ hook จนกว่าจะมีตัวใดเปลี่ยน config จริง หากไม่มี hook ของ provider เขียนรายการ config ตระกูล Google ที่รองรับใหม่ ตัวทำให้ config ของ Google ที่รวมมาให้ยังคงทำงาน
      - `resolveConfigApiKey` ใช้ hook ของ provider เมื่อเปิดเผยไว้ path `amazon-bedrock` ที่รวมมาให้ยังมี resolver env-marker ของ AWS ในตัวที่นี่ด้วย แม้ว่า auth runtime ของ Bedrock เองยังใช้ chain เริ่มต้นของ AWS SDK
      - `resolveSystemPromptContribution` ให้ provider ฉีดคำแนะนำ system-prompt ที่รับรู้ cache สำหรับกลุ่ม model ได้ ควรใช้แทน `before_prompt_build` เมื่อพฤติกรรมเป็นของ provider/กลุ่ม model หนึ่ง และควรรักษาการแยก cache แบบ stable/dynamic

      สำหรับคำอธิบายโดยละเอียดและตัวอย่างจริง โปรดดู [Internals: Provider Runtime Hooks](/th/plugins/architecture-internals#provider-runtime-hooks)
    </Accordion>

  </Step>

  <Step title="เพิ่มความสามารถเสริม (ไม่บังคับ)">
    ### ขั้นตอนที่ 5: เพิ่มความสามารถเสริม

    Plugin ของ provider สามารถลงทะเบียน speech, realtime transcription, realtime
    voice, media understanding, image generation, video generation, web fetch,
    และ web search ควบคู่ไปกับ text inference ได้ OpenClaw จัดประเภทสิ่งนี้เป็น Plugin
    แบบ **hybrid-capability** — ซึ่งเป็นแพตเทิร์นที่แนะนำสำหรับ Plugin ของบริษัท
    (หนึ่ง Plugin ต่อ vendor) ดู
    [Internals: Capability Ownership](/th/plugins/architecture#capability-ownership-model)

    ลงทะเบียนแต่ละความสามารถภายใน `register(api)` ควบคู่กับการเรียก
    `api.registerProvider(...)` ที่มีอยู่ เลือกเฉพาะแท็บที่คุณต้องใช้:

    <Tabs>
      <Tab title="Speech (TTS)">
        ```typescript
        import {
          assertOkOrThrowProviderError,
          postJsonRequest,
        } from "openclaw/plugin-sdk/provider-http";

        api.registerSpeechProvider({
          id: "acme-ai",
          label: "Acme Speech",
          isConfigured: ({ config }) => Boolean(config.messages?.tts),
          synthesize: async (req) => {
            const { response, release } = await postJsonRequest({
              url: "https://api.example.com/v1/speech",
              headers: new Headers({ "Content-Type": "application/json" }),
              body: { text: req.text },
              timeoutMs: req.timeoutMs,
              fetchFn: fetch,
              auditContext: "acme speech",
            });
            try {
              await assertOkOrThrowProviderError(response, "Acme Speech API error");
              return {
                audioBuffer: Buffer.from(await response.arrayBuffer()),
                outputFormat: "mp3",
                fileExtension: ".mp3",
                voiceCompatible: false,
              };
            } finally {
              await release();
            }
          },
        });
        ```

        ใช้ `assertOkOrThrowProviderError(...)` สำหรับความล้มเหลวของ HTTP ของผู้ให้บริการ เพื่อให้
        Plugin ใช้การอ่านเนื้อหาข้อผิดพลาดแบบจำกัดขนาด การแยกวิเคราะห์ข้อผิดพลาด JSON และ
        ส่วนต่อท้าย request-id ร่วมกัน
      </Tab>
      <Tab title="Realtime transcription">
        ควรใช้ `createRealtimeTranscriptionWebSocketSession(...)` — ตัวช่วยที่ใช้ร่วมกัน
        จัดการการจับ proxy, reconnect backoff, การ flush ตอนปิด, ready
        handshakes, การจัดคิวเสียง และการวินิจฉัย close-event Plugin ของคุณ
        เพียงแปลง upstream events เท่านั้น

        ```typescript
        api.registerRealtimeTranscriptionProvider({
          id: "acme-ai",
          label: "Acme Realtime Transcription",
          isConfigured: () => true,
          createSession: (req) => {
            const apiKey = String(req.providerConfig.apiKey ?? "");
            return createRealtimeTranscriptionWebSocketSession({
              providerId: "acme-ai",
              callbacks: req,
              url: "wss://api.example.com/v1/realtime-transcription",
              headers: { Authorization: `Bearer ${apiKey}` },
              onMessage: (event, transport) => {
                if (event.type === "session.created") {
                  transport.sendJson({ type: "session.update" });
                  transport.markReady();
                  return;
                }
                if (event.type === "transcript.final") {
                  req.onTranscript?.(event.text);
                }
              },
              sendAudio: (audio, transport) => {
                transport.sendJson({
                  type: "audio.append",
                  audio: audio.toString("base64"),
                });
              },
              onClose: (transport) => {
                transport.sendJson({ type: "audio.end" });
              },
            });
          },
        });
        ```

        ผู้ให้บริการ STT แบบ batch ที่ POST เสียง multipart ควรใช้
        `buildAudioTranscriptionFormData(...)` จาก
        `openclaw/plugin-sdk/provider-http` ตัวช่วยนี้ทำให้ชื่อไฟล์อัปโหลด
        เป็นรูปแบบมาตรฐาน รวมถึงการอัปโหลด AAC ที่ต้องใช้ชื่อไฟล์แบบ M4A
        สำหรับ API ถอดเสียงที่เข้ากันได้
      </Tab>
      <Tab title="Realtime voice">
        ```typescript
        api.registerRealtimeVoiceProvider({
          id: "acme-ai",
          label: "Acme Realtime Voice",
          isConfigured: ({ providerConfig }) => Boolean(providerConfig.apiKey),
          createBridge: (req) => ({
            // Set this only if the provider accepts multiple tool responses for
            // one call, for example an immediate "working" response followed by
            // the final result.
            supportsToolResultContinuation: false,
            connect: async () => {},
            sendAudio: () => {},
            setMediaTimestamp: () => {},
            handleBargeIn: () => {},
            submitToolResult: () => {},
            acknowledgeMark: () => {},
            close: () => {},
            isConnected: () => true,
          }),
        });
        ```

        ใช้งาน `handleBargeIn` เมื่อ transport ตรวจจับได้ว่ามนุษย์กำลัง
        ขัดจังหวะการเล่นเสียงของผู้ช่วย และผู้ให้บริการรองรับการตัดทอนหรือ
        ล้างการตอบกลับเสียงที่กำลังทำงานอยู่
      </Tab>
      <Tab title="Media understanding">
        ```typescript
        api.registerMediaUnderstandingProvider({
          id: "acme-ai",
          capabilities: ["image", "audio"],
          describeImage: async (req) => ({ text: "A photo of..." }),
          transcribeAudio: async (req) => ({ text: "Transcript..." }),
        });
        ```
      </Tab>
      <Tab title="Image and video generation">
        ความสามารถด้านวิดีโอใช้โครงสร้างที่ **รับรู้โหมด**: `generate`,
        `imageToVideo` และ `videoToVideo` ฟิลด์รวมแบบแบนอย่าง
        `maxInputImages` / `maxInputVideos` / `maxDurationSeconds` ยังไม่พอ
        สำหรับประกาศการรองรับโหมดแปลงหรือปิดใช้งานโหมดอย่างชัดเจน
        การสร้างเพลงใช้รูปแบบเดียวกันด้วยบล็อก `generate` /
        `edit` ที่ระบุอย่างชัดเจน

        ```typescript
        api.registerImageGenerationProvider({
          id: "acme-ai",
          label: "Acme Images",
          generate: async (req) => ({ /* image result */ }),
        });

        api.registerVideoGenerationProvider({
          id: "acme-ai",
          label: "Acme Video",
          capabilities: {
            generate: { maxVideos: 1, maxDurationSeconds: 10, supportsResolution: true },
            imageToVideo: {
              enabled: true,
              maxVideos: 1,
              maxInputImages: 1,
              maxInputImagesByModel: { "acme/reference-to-video": 9 },
              maxDurationSeconds: 5,
            },
            videoToVideo: { enabled: false },
          },
          generateVideo: async (req) => ({ videos: [] }),
        });
        ```
      </Tab>
      <Tab title="Web fetch and search">
        ```typescript
        api.registerWebFetchProvider({
          id: "acme-ai-fetch",
          label: "Acme Fetch",
          hint: "Fetch pages through Acme's rendering backend.",
          envVars: ["ACME_FETCH_API_KEY"],
          placeholder: "acme-...",
          signupUrl: "https://acme.example.com/fetch",
          credentialPath: "plugins.entries.acme.config.webFetch.apiKey",
          getCredentialValue: (fetchConfig) => fetchConfig?.acme?.apiKey,
          setCredentialValue: (fetchConfigTarget, value) => {
            const acme = (fetchConfigTarget.acme ??= {});
            acme.apiKey = value;
          },
          createTool: () => ({
            description: "Fetch a page through Acme Fetch.",
            parameters: {},
            execute: async (args) => ({ content: [] }),
          }),
        });

        api.registerWebSearchProvider({
          id: "acme-ai-search",
          label: "Acme Search",
          search: async (req) => ({ content: [] }),
        });
        ```
      </Tab>
    </Tabs>

  </Step>

  <Step title="Test">
    ### ขั้นตอนที่ 6: ทดสอบ

    ```typescript src/provider.test.ts
    import { describe, it, expect } from "vitest";
    // Export your provider config object from index.ts or a dedicated file
    import { acmeProvider } from "./provider.js";

    describe("acme-ai provider", () => {
      it("resolves dynamic models", () => {
        const model = acmeProvider.resolveDynamicModel!({
          modelId: "acme-beta-v3",
        } as any);
        expect(model.id).toBe("acme-beta-v3");
        expect(model.provider).toBe("acme-ai");
      });

      it("returns catalog when key is available", async () => {
        const result = await acmeProvider.catalog!.run({
          resolveProviderApiKey: () => ({ apiKey: "test-key" }),
        } as any);
        expect(result?.provider?.models).toHaveLength(2);
      });

      it("returns null catalog when no key", async () => {
        const result = await acmeProvider.catalog!.run({
          resolveProviderApiKey: () => ({ apiKey: undefined }),
        } as any);
        expect(result).toBeNull();
      });
    });
    ```

  </Step>
</Steps>

## เผยแพร่ไปยัง ClawHub

Plugin ผู้ให้บริการเผยแพร่ด้วยวิธีเดียวกับ Plugin โค้ดภายนอกอื่นๆ:

```bash
clawhub package publish your-org/your-plugin --dry-run
clawhub package publish your-org/your-plugin
```

อย่าใช้นามแฝงการเผยแพร่แบบเดิมที่ใช้เฉพาะ skill ที่นี่ แพ็กเกจ Plugin ควรใช้
`clawhub package publish`

## โครงสร้างไฟล์

```
<bundled-plugin-root>/acme-ai/
├── package.json              # openclaw.providers metadata
├── openclaw.plugin.json      # Manifest with provider auth metadata
├── index.ts                  # definePluginEntry + registerProvider
└── src/
    ├── provider.test.ts      # Tests
    └── usage.ts              # Usage endpoint (optional)
```

## ข้อมูลอ้างอิงลำดับแคตตาล็อก

`catalog.order` ควบคุมว่าแคตตาล็อกของคุณผสานเมื่อใดเมื่อเทียบกับ
ผู้ให้บริการในตัว:

| ลำดับ     | เมื่อใด          | กรณีการใช้งาน                                        |
| --------- | ------------- | ----------------------------------------------- |
| `simple`  | รอบแรก    | ผู้ให้บริการที่ใช้ API-key แบบตรงไปตรงมา                         |
| `profile` | หลัง simple  | ผู้ให้บริการที่ถูกควบคุมด้วย auth profiles                |
| `paired`  | หลัง profile | สร้างรายการที่เกี่ยวข้องหลายรายการ             |
| `late`    | รอบสุดท้าย     | แทนที่ผู้ให้บริการที่มีอยู่ (ชนะเมื่อชนกัน) |

## ขั้นตอนถัดไป

- [Plugin ช่องทาง](/th/plugins/sdk-channel-plugins) — หาก Plugin ของคุณให้บริการช่องทางด้วย
- [SDK Runtime](/th/plugins/sdk-runtime) — ตัวช่วย `api.runtime` (TTS, search, subagent)
- [ภาพรวม SDK](/th/plugins/sdk-overview) — ข้อมูลอ้างอิงการ import subpath ทั้งหมด
- [รายละเอียดภายในของ Plugin](/th/plugins/architecture-internals#provider-runtime-hooks) — รายละเอียด hook และตัวอย่างที่ bundled ไว้

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

- [การตั้งค่า Plugin SDK](/th/plugins/sdk-setup)
- [การสร้าง Plugin](/th/plugins/building-plugins)
- [การสร้าง Plugin ช่องทาง](/th/plugins/sdk-channel-plugins)
