BroadRouter

Tool calling sa open model: schema, parallel call, retry

Ng BroadNet Inference team · 4 minutong basa · Nailathala · Na-update

Parehong tools at tool_calls format ng OpenAI ang gamit ng mga open model sa OpenAI-compatible na API. Panatilihing maliit at flat ang schema, i-parse ang arguments bilang JSON string, i-validate bago magpatakbo ng kahit ano, at ibalik ang error sa model bilang tool result para makapag-retry ito. Lagyan ng limit ang mga hakbang. Sa BroadNet, GLM 5.3 at Qwen3.8 27B ang may nakalistang tool support.

Ang tool calling ang nagpapabago sa isang model para maging agent. Sa mga open model sa OpenAI-compatible na API, pareho ang request format sa gagamitin mo sa OpenAI. Ang nagkakaiba ay kung gaano kadalas may nagkakamali at kung ano ang ginagawa ng server para pigilan ito. Tinatalakay ng post na ito ang format, kung paano sumulat ng schema na kayang hawakan nang maayos ng mga open model, ang parallel call, ang limang palyang talagang makikita mo, at isang Python loop na nakakalusot sa mga ito.

Paano gumagana ang tool calling sa OpenAI-compatible na API?

  1. Ipinapadala mo ang messages kasama ang tools list. May pangalan, description at JSON Schema para sa arguments ang bawat tool.
  2. Sumasagot ang model ng finish_reason: "tool_calls" at tool_calls list. May id, pangalan ng function at arguments bilang JSON string ang bawat entry.
  3. Pinapatakbo ng code mo ang bawat call at nagdadagdag ng isang role: "tool" na message kada call, na may katugmang tool_call_id.
  4. Tinatawag mo ulit ang API. Sasagot ang model o hihingi ng iba pang tool.

Hindi kailanman nagpapatakbo ng anuman ang model. Ang code mo ang nagpapasya kung ano ang ie-execute.

Paano dapat isulat ang tool schema?

Mas maaasahang sinusunod ng mga open model ang mga simpleng schema. Galing ang mga patakarang ito sa gabay ng OpenAI at sa mga karaniwang nasisira:

  • Pangalanan ang tool ayon sa aksyon, gaya ng read_file o search_code, at sabihin sa description kung kailan gagamitin ang bawat isa.
  • Panatilihing maikli ang listahan. Tinatawag ng gabay ng OpenAI na soft suggestion ang wala pang 20 function sa simula ng isang turn. Ipinapadala rin ang bawat schema sa bawat call; tingnan ang token budget ng agent.
  • Mas piliin ang flat na arguments. String, number, boolean at enum. Iwasan ang malalim na nesting at free-form na object.
  • Gumamit ng enum para sa mga nakapirming pagpipilian, para hindi makaimbento ng value ang model. Ginagawa ng JSON schema generator na flat na schema ang isang sample na arguments object na puwede mong i-paste sa parameters.
  • Markahan ang mga required na field. Kailangan ng strict mode ng OpenAI ang additionalProperties: false at nasa required ang bawat field, na may null bilang type para sa mga optional. Iba-iba kung ipinapatupad ng provider ang strict, kaya mag-validate pa rin.

Paano naman ang parallel tool call?

Puwedeng magbalik ang model ng ilang entry sa tool_calls sa iisang turn, halimbawa tatlong file read. Patakbuhin nang sabay ang magkakahiwalay na call at magbalik ng isang result kada tool_call_id, kahit anong pagkakasunod. Kung may side effect ang mga tool mo na nakadepende sa isa’t isa, itakda ang parallel_tool_calls: false; sabi ng gabay ng OpenAI, nililimitahan nito ang model sa zero o isang call kada turn. I-test kung sinusunod ito ng provider mo.

Bakit pumapalya ang mga tool call?

Palya Ang nakikita mo Ayos
Sirang arguments Nagra-raise ang json.loads Ibalik ang parse error bilang tool result; i-retry
Hindi tugma sa schema Kulang na field, maling type, inimbentong enum Mag-validate; ibalik ang validation error
Hindi kilalang tool Pangalang hindi mo kailanman dinepina Ibalik ang “unknown tool, available: …”
Walang call kahit kailangan Text na sagot ang dumating tool_choice: "required" o isang pinangalanang function
Naputol na call finish_reason: "length" Taasan ang max_tokens; kahati nito ang reasoning

Inaasahan ang unang dalawa, hindi bihira. Sabi ng tool-calling docs ng vLLM, sa auto mode, maliban kung may tool na nagtatakda ng strict: true (o nagpapatupad ang server ng minimum na strictness) at sinusuportahan ng parser ng model ang constraints, “vLLM extracts tool calls from raw text, so arguments may occasionally be malformed or violate the function’s parameter schema.” (salin: kinukuha ng vLLM ang tool call mula sa raw text, kaya paminsan-minsang sira ang arguments o lumalabag sa parameter schema ng function.) Ang pinangalanang function ay gumagamit ng structured-outputs backend ng vLLM. Puwedeng iba ang paraan ng pag-serve ng provider mo, kaya ituring na sapilitan ang validation.

Ang huling row ang humuhuli sa mga gumagamit ng reasoning model. Nag-iisip muna bago sumagot ang GLM 5.3 at Qwen3.8 27B, at kasama ang pag-iisip sa max_tokens. Ipinapaliwanag ng kung bakit bumabalik na walang laman o naputol ang sagot kung gaano kalaking puwang ang dapat iwan.

Isang tool loop na nagva-validate at nagre-retry

import json, os
from openai import OpenAI
from jsonschema import validate, ValidationError

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=4)
MODEL = "broadnet/glm-5.3"

TOOLS = [{"type": "function", "function": {
    "name": "get_order_status",
    "description": "Look up one order by its ID. Use when the user asks where an order is.",
    "parameters": {"type": "object",
                   "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"], "additionalProperties": False}}}]
SCHEMAS = {t["function"]["name"]: t["function"]["parameters"] for t in TOOLS}
IMPL = {"get_order_status": lambda order_id: f"Order {order_id}: shipped"}

def run_call(call):
    name = call.function.name
    if name not in IMPL:
        return f"Error: unknown tool {name}. Available: {', '.join(IMPL)}"
    try:
        args = json.loads(call.function.arguments or "{}")
        validate(args, SCHEMAS[name])
    except (json.JSONDecodeError, ValidationError) as e:
        return f"Error: invalid arguments ({e}). Send the call again with valid JSON."
    return str(IMPL[name](**args))

def agent(messages, max_steps=8):
    for _ in range(max_steps):
        r = client.chat.completions.create(model=MODEL, messages=messages,
                                           tools=TOOLS, max_tokens=4000)
        msg = r.choices[0].message
        if r.choices[0].finish_reason == "length":
            raise RuntimeError("Output limit reached; raise max_tokens")
        messages.append(msg.model_dump(exclude_none=True))
        if not msg.tool_calls:
            return msg.content
        for call in msg.tool_calls:
            messages.append({"role": "tool", "tool_call_id": call.id,
                             "content": run_call(call)})
    raise RuntimeError("Step limit reached")

Tatlong desisyon sa disenyo ang mahalaga rito:

  1. Bumabalik sa model ang mga error bilang tool result. Nakikita ng model kung ano ang mali at kadalasang naitatama ito sa susunod na turn. Kapag nag-raise ka ng exception, nasasayang ang pagkakataong iyon.
  2. May hangganan ang loop. Pinapahinto ng max_steps ang model na paulit-ulit na tumatawag ng tool nang walang usad.
  3. Hiwalay ang transport retry. Ang max_retries sa client ang humahawak sa 429 at 5xx. Sa loop hinahawakan ang maling arguments. Huwag paghaluin ang dalawa; tingnan ang errors at retries.

Para sa mga tool na may side effect, gaya ng pagpapadala ng email, magdagdag ng idempotency key para hindi dalawang beses kumilos ang inulit na hakbang. Tinatalakay ito sa long-running na agent.

Aling mga model ng BroadNet ang sumusuporta sa tool calling?

Model Nakalista ang tools Context Tala
GLM 5.3 Oo 1,048,576 May structured output din
Qwen3.8 27B Oo 262,144 May image input din
DeepSeek V4.1 Flash Hindi nakalista 1,048,576 Image input; i-test ang tools bago umasa sa mga ito
Gemma 4 VL 26B Hindi nakalista 32,768 Hindi para sa tool loop

Para pumili sa dalawang model na may tool support, tingnan ang GLM 5.3 vs Qwen3.8 27B. Kapag kailangang tumugma sa isang hugis ang huling sagot pero walang function na kailangang patakbuhin, mas simple ang structured output kaysa sa tool.

Saan bagay ang BroadNet Inference

Sine-serve ng BroadNet Inference ang GLM 5.3 at Qwen3.8 27B na may nakalistang tool calling, sa pamamagitan ng standard na chat-completions format, kaya tumatakbo nang walang pagbabago ang loop sa itaas gamit ang OpenAI Python SDK. Nasa pricing page ang presyo kada token. Hindi ito nagho-host ng server-side na tool gaya ng web search o code execution, at hindi nakalista sa docs nito ang tool calling para sa DeepSeek V4.1 Flash, ang model sa mga unlimited na plan. Para sa agent na mabigat sa tools, gamitin ang GLM 5.3 o Qwen3.8 27B kada token. Kung gusto mo pa rin ang flat plan, tingnan sa isang $1 na Meteor hour kung maaasahang tinatawag ng DeepSeek V4.1 Flash ang mga tool mo bago bumili ng isang buwan.

Mga tanong

Sumusuporta ba sa function calling ang mga open model?

Marami, pero depende ang suporta sa model at sa paraan ng pag-serve ng provider. Sa BroadNet Inference, nakalista sa docs ang tool calling para sa GLM 5.3 at Qwen3.8 27B. Hindi ito nakalista para sa DeepSeek V4.1 Flash o Gemma 4 VL 26B.

Bakit invalid JSON ang arguments ng tool call ko?

Maliban kung kinokontrol ng server ang decoding, ginagawa ang arguments bilang text at pina-parse pagkatapos. Sabi ng docs ng vLLM, puwedeng paminsan-minsang sira ang arguments na kinuha mula sa raw text. Saluhin ang parse error at ibalik ito bilang tool result para maitama ng model ang sarili.

Paano ko io-off ang parallel tool call?

Sa OpenAI format, itakda ang parallel_tool_calls sa false. Nililimitahan nito ang model sa zero o isang tool call kada turn. I-check kung sinusunod ng provider mo ang field.

Bakit text ang sagot ng model sa halip na tumawag ng tool?

Sa tool_choice na auto, ang model ang nagpapasya. Itakda ang tool_choice sa required, o sa isang tiyak na function, kapag sapilitan ang call. I-check din kung sinasabi ng description ng tool kung kailan ito gagamitin.

Bakit naputol ang tool call ko?

Sa mga reasoning model, kasama sa max_tokens ang pag-iisip. Puwedeng matapos sa gitna ng arguments ang sagot kapag maliit ang limit. Tingnan ang finish_reason at taasan ang max_tokens.

Basahin bilang MarkdownTanungin ang ChatGPTTanungin ang ClaudeTanungin ang Perplexity