메뉴
AI function calling / tool use patterns — schema definition, tool dispatch, streaming tool calls, and error handling.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
SOC 직업 분류 기준
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/InugamiDev/ultrathink-oss --skill ai-function-calling명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
SKILL.md 표시 중
Unified design foundations — design system architecture, tokens, component specs, visual principles, creative vision, figma integration, plus brand design system loader (66 real brands via DESIGN.md). Absorbs design, design-system, design-systems, design-principles, design-router, creative-vision, figma, design-md.
Render, summarize, and present markdown documents and structured content in multiple output modes
Ultra UI skill - combines Google's DESIGN.md spec (machine-readable design tokens) with the ui-ux-pro-max knowledge base (91 styles, 161 palettes, 73 font pairings, 161 products, 104 UX guidelines, 25 chart types). Generates lint-clean DESIGN.md files, validates token references and WCAG contrast, exports Tailwind/DTCG tokens, and diffs design systems version-over-version.
| name | ai-function-calling |
| description | AI function calling / tool use patterns — schema definition, tool dispatch, streaming tool calls, and error handling. |
| layer | utility |
| category | ai-ml |
| triggers | ["function calling","tool use","tool call","ai tools","function schema","tool dispatch"] |
| inputs | ["Tool schema definitions or requirements","Function calling integration questions","Streaming tool call patterns","Error handling for tool dispatch"] |
| outputs | ["Type-safe tool schemas with validation","Tool dispatch implementations","Streaming tool call handlers","Error recovery patterns for failed tool calls"] |
| linksTo | ["ai-agents","claude-api","openai","ai-sdk"] |
| linkedFrom | [] |
| riskLevel | medium |
| memoryReadPolicy | selective |
| memoryWritePolicy | none |
| sideEffects | [] |
Provide expert guidance on designing, implementing, and managing AI function calling (tool use) across major LLM providers. Covers schema definition, runtime dispatch, streaming tool calls, parallel execution, error handling, and security considerations.
Zod-based schemas — Define tools with runtime validation and TypeScript inference:
import { z } from 'zod';
// Define tool parameters with Zod
const getWeatherParams = z.object({
location: z.string().describe('City name or coordinates'),
units: z.enum(['celsius', 'fahrenheit']).default('celsius'),
});
// Generic tool definition type
interface ToolDefinition<T extends z.ZodType> {
name: string;
description: string;
parameters: T;
execute: (args: z.infer<T>) => Promise<unknown>;
}
// Create a type-safe tool
const weatherTool: ToolDefinition<typeof getWeatherParams> = {
name: 'get_weather',
description: 'Get the current weather for a location',
: getWeatherParams,
: (args) => {
{ location, units } = args;
{ : , units, location };
},
};
JSON Schema generation — Convert Zod schemas to JSON Schema for API calls:
import { zodToJsonSchema } from 'zod-to-json-schema';
function toolToApiFormat(tool: ToolDefinition<z.ZodType>) {
return {
type: 'function' as const,
function: {
name: tool.name,
description: tool.description,
parameters: zodToJsonSchema(tool.parameters, {
$refStrategy: 'none',
target: 'openAI',
}),
},
};
}
import Anthropic from '@anthropic-ai/sdk';
const client = new Anthropic();
const tools: Anthropic.Messages.Tool[] = [
{
name: 'get_weather',
description: 'Get the current weather for a location',
input_schema: {
type: 'object',
properties: {
location: { type: 'string', description: 'City name' },
units: { type: 'string', enum: ['celsius', 'fahrenheit'] },
},
required: ['location'],
},
},
];
// Agentic loop — keep calling until no more tool_use blocks
async function agentLoop(userMessage: string) {
const messages: Anthropic.Messages.MessageParam[] = [
{ role: 'user', content: userMessage },
];
while (true) {
const response = await client.messages.create({
model: 'claude-sonnet-4-20250514',
max_tokens: 4096,
tools,
messages,
});
// Collect assistant response
messages.push({ role: 'assistant', content: response.content });
// Check if there are tool use blocks
const toolUseBlocks = response.content.filter(
(block): block is Anthropic.Messages.ToolUseBlock =>
block.type === 'tool_use'
);
if (toolUseBlocks.length === 0 || response.stop_reason === 'end_turn') {
return response; // No more tools to call
}
// Execute tools and build tool_result blocks
const toolResults: Anthropic.Messages.ToolResultBlockParam[] =
await Promise.all(
toolUseBlocks.map(async (block) => {
try {
const result = await dispatch(block.name, block.input);
return {
type: 'tool_result' as const,
tool_use_id: block.id,
content: JSON.stringify(result),
};
} catch (error) {
return {
type: 'tool_result' as const,
tool_use_id: block.id,
content: `Error: ${(error as Error).message}`,
is_error: true,
};
}
})
);
messages.push({ role: 'user', content: toolResults });
}
}
Registry-based dispatch — Type-safe, extensible tool routing:
type ToolRegistry = Map<string, ToolDefinition<z.ZodType>>;
class ToolDispatcher {
private registry: ToolRegistry = new Map();
register(tool: ToolDefinition<z.ZodType>) {
this.registry.set(tool.name, tool);
}
async dispatch(name: string, rawArgs: unknown): Promise<unknown> {
const tool = this.registry.get(name);
if (!tool) {
throw new Error(`Unknown tool: ${name}`);
}
// Validate args against schema
const parsed = tool.parameters.safeParse(rawArgs);
if (!parsed.success) {
throw new Error(
`Invalid args for ${name}: ${parsed.error.issues.map((i) => i.message).join(', ')}`
);
}
return tool.execute(parsed.data);
}
getToolDefinitions() {
return Array.from(this.registry.values()).map(toolToApiFormat);
}
}
Anthropic streaming — Handle tool use blocks as they arrive:
async function streamWithTools(messages: Anthropic.Messages.MessageParam[]) {
const stream = client.messages.stream({
model: 'claude-sonnet-4-20250514',
max_tokens: 4096,
tools,
messages,
});
// Accumulate the full response for tool use detection
const response = await stream.finalMessage();
// Process tool calls from the accumulated response
const toolBlocks = response.content.filter(
(b): b is Anthropic.Messages.ToolUseBlock => b.type === 'tool_use'
);
// Stream text blocks to the UI while processing tools in background
for await (const event of stream) {
if (
event.type === 'content_block_delta' &&
event.delta.type === 'text_delta'
) {
process.stdout.write(event.delta.text);
}
}
return { response, toolBlocks };
}
import { generateText, tool } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { z } from 'zod';
const result = await generateText({
model: anthropic('claude-sonnet-4-20250514'),
tools: {
getWeather: tool({
description: 'Get weather for a location',
parameters: z.object({
location: z.string(),
}),
execute: async ({ location }) => {
return { temperature: 22, location };
},
}),
},
maxSteps: 5, // Allow up to 5 tool call rounds
prompt: 'What is the weather in Tokyo?',
});
// When the model returns multiple tool_use blocks, execute in parallel
async function executeToolsParallel(
toolBlocks: Anthropic.Messages.ToolUseBlock[],
dispatcher: ToolDispatcher
) {
const results = await Promise.allSettled(
toolBlocks.map(async (block) => ({
tool_use_id: block.id,
result: await dispatcher.dispatch(block.name, block.input),
}))
);
return results.map((r, i) => {
if (r.status === 'fulfilled') {
return {
type: 'tool_result' as const,
tool_use_id: r.value.tool_use_id,
content: JSON.stringify(r.value.result),
};
}
return {
type: 'tool_result' as const,
tool_use_id: toolBlocks[i].id,
content: `Error: ${r.reason?.message ?? 'Unknown error'}`,
is_error: true,
};
});
}
// Restrict tool capabilities based on user permissions
interface ToolPermission {
allowedTools: string[];
maxCallsPerTurn: number;
timeout: number;
}
function createSandboxedDispatcher(
dispatcher: ToolDispatcher,
permissions: ToolPermission
) {
let callCount = 0;
return async (name: string, args: unknown) => {
if (!permissions.allowedTools.includes(name)) {
throw new Error(`Tool ${name} is not permitted`);
}
if (++callCount > permissions.maxCallsPerTurn) {
throw new Error('Tool call limit exceeded');
}
const controller = new AbortController();
const timeout = setTimeout(
() => controller.abort(),
permissions.timeout
);
try {
return await dispatcher.dispatch(name, args);
} finally {
clearTimeout(timeout);
}
};
}
is_error: true (Anthropic) or structured error objects so the model can self-correct.enum over free-text — Constrain parameters to known values where possible to reduce hallucination.| Pitfall | Problem | Fix |
|---|---|---|
Missing tool_use_id in results | API rejects the response | Always map result back to the original tool_use_id |
| No error handling in dispatch | Unhandled rejection crashes the loop | Wrap every tool execution in try/catch |
| Infinite tool loops | Model keeps calling tools forever | Set maxSteps or a manual iteration limit |
| Over-complex schemas | Model struggles with deeply nested params | Flatten schemas; use separate tools for complex operations |
Forgetting is_error flag | Model treats error text as success data | Always set is_error: true on failures |
| Not validating tool output | Downstream code crashes on unexpected shape | Validate tool return values before serializing |