Tool Call Rendering
Render your agent's tool calls with custom UI components.
What is this?
Tools are how an LLM invokes predefined, typically-deterministic functions. Tool rendering lets you decide how each of those tool calls appears in the chat. Instead of showing raw JSON, you register a Vue component that draws a branded card for the call (arguments, live status, and the eventual result). This is the Generative UI variant CopilotKit calls tool rendering.
When should I use this?
Render tool calls when you want to:
- Show users exactly what tools the agent is invoking and with what arguments
- Display live progress indicators while a tool executes
- Render rich, polished results once a tool completes
- Give tool-heavy agents a transparent, on-brand chat experience
Default tool rendering (zero-config)
The simplest entry point is useDefaultRenderTool() with no arguments. CopilotKit registers its built-in default renderer as the * wildcard: every tool call renders as a status card (tool name, live Running → Done state, collapsible arguments/result) without you writing any UI.
Without this composable, CopilotKit has no * renderer and tool calls are not shown. The user only sees the assistant's final text summary.
<script setup lang="ts">
import { CopilotChat, useDefaultRenderTool } from "@copilotkit/vue/v2";
useDefaultRenderTool();
</script>
<template><CopilotChat /></template>Custom catch-all
Once you want on-brand chrome, pass a render component or function to useDefaultRenderTool. It's a convenience wrapper around useRenderTool({ name: "*", ... }): one wildcard renderer handles every tool call, named or not.
useDefaultRenderTool({ render: BrandedToolCard });Per-tool renderers
The most expressive path is one renderer per tool name. Each renderer receives the tool's parsed arguments, a live status, and, once the agent returns, the result.
-
Write the card component:
src/components/WeatherToolCard.vue <script setup lang="ts"> defineProps<{ parameters: { city?: string }; status: "inProgress" | "executing" | "complete"; result?: string; }>(); </script> <template> <p v-if="status !== 'complete'">Checking {{ parameters.city ?? "…" }}</p> <article v-else> <strong>{{ parameters.city }}</strong> <pre>{{ result }}</pre> </article> </template> -
Register it with
useRenderToolin a component:src/components/AgentExperience.vue <script setup lang="ts"> import { z } from "zod"; import { CopilotChat, useDefaultRenderTool, useRenderTool } from "@copilotkit/vue/v2"; import WeatherToolCard from "./WeatherToolCard.vue"; useRenderTool({ name: "get_weather", parameters: z.object({ city: z.string() }), render: WeatherToolCard, }); useDefaultRenderTool(); // wildcard fallback for every other tool </script> <template><CopilotChat /></template> -
Mount that component under
CopilotKitProvider:src/App.vue <script setup lang="ts"> import { CopilotKitProvider } from "@copilotkit/vue/v2"; import AgentExperience from "./components/AgentExperience.vue"; </script> <template> <CopilotKitProvider runtime-url="/api/copilotkit"><AgentExperience /></CopilotKitProvider> </template>
parameters is partial while arguments stream. Read required fields only after the status advances from inProgress. The result is a string when status is complete; parse it only if your backend deliberately returns a documented serialized shape.
The name you pass to useRenderTool must match the tool name the agent exposes. That is how CopilotKit routes the call to your component.
Per-tool renderers compose with a catch-all: named renderers claim the "interesting" tools and a wildcard handles everything else. The example registers the built-in wildcard after the named get_weather renderer.
If the renderer closes over reactive values, pass Vue watch sources as the second argument:
useRenderTool({ name: "get_weather", parameters, render: WeatherToolCard }, [locale]);The backend tool definition
The frontend renderer only sees what the agent sends down. The matching backend must expose a tool named get_weather, return structured data, and let the frontend renderer with the same name paint the card. The Vue renderer does not create or execute that backend tool.
from random import choice, randint
from langchain.agents import create_agent
from langchain.tools import tool
from langchain_openai import ChatOpenAI
from copilotkit import CopilotKitMiddleware
# Multi-tool chaining prompt.
#
# The goal of this demo is to surface MULTIPLE tool-call cards per turn so
# the rendering patterns (per-tool + catch-all) get exercised visibly. The
# prompt nudges the model toward an explore-then-enrich pattern (e.g.
# `get_weather("Tokyo")` -> `search_flights(..., "Tokyo")`) without forcing
# a rigid recipe: we describe the *habit*, not a chain.
SYSTEM_PROMPT = (
"You are a helpful travel & lifestyle concierge. You have mock tools "
"for weather, flights, stock prices, and dice rolls - they all return "
"fake data, so call them liberally.\n\n"
"Your habit is to CHAIN tools when one answer naturally invites another. "
"For a single user question, call at least TWO tools in succession when "
"the topic allows before composing your final reply. Examples of "
"helpful chains you should default to:\n"
" - 'What's the weather in Tokyo?' -> call get_weather('Tokyo'), then "
"call search_flights(origin='SFO', destination='Tokyo') so the user "
"also sees how to get there.\n"
" - 'How is AAPL doing?' -> call get_stock_price('AAPL'), then call "
"get_stock_price on a related ticker (e.g. 'MSFT' or 'GOOGL') for "
"comparison.\n"
" - 'Roll a d20' -> call roll_dice(20), then call roll_dice again with "
"a different number of sides so the user sees a contrast.\n"
" - 'Find flights from SFO to JFK' -> call search_flights, then call "
"get_weather on the destination city.\n\n"
"Only skip chaining when the user has clearly asked for a single, "
"atomic answer and more tool calls would feel intrusive. Never "
"fabricate data that a tool could provide."
)
@tool
def get_weather(location: str) -> dict:
"""Get the current weather for a given location.
Useful on its own for weather questions, and a great companion to
`search_flights` - always consider checking the weather at a
destination the user is flying to, and checking flights to any
city whose weather the user has just asked about.
"""
return {
"city": location,
"temperature": 68,
"humidity": 55,
"wind_speed": 10,
"conditions": "Sunny",
}
How is this guide?