Implementation omitted for brevity [chapter] deterministic

return {"id": post_id, "title": "Sample Post"}

`

When the agent reasons that it needs to retrieve a post, it issues a function call:

```json { "tool": "get_blog_post", "arguments": {"post_id": 42} }

`

The orchestration layer extracts the tool name and arguments, calls get_blog_post(42), and returns the result to the agent. The agent can then incorporate the result into its next reasoning step. This pattern enables the agent to act on external data without hard-coding every possible operation. Tool use is not limited to simple lookups. You can design tools that perform complex operations, such as generating embeddings, querying a local knowledge graph, or invoking a **Cybersecurity Specialist** service to analyze a threat vector. The key is to expose a clean, deterministic interface so that the agent’s reasoning layer can reliably invoke the tool and interpret the result.

Function Calling in Practice Function calling requires careful handling of schema validation, error recovery, and logging. The model may produce malformed JSON, misspell a tool name, or provide arguments that do not match the tool’s signature. A robust implementation must: 1. **Validate** the JSON payload against a schema. 2. **Sanitize** arguments to prevent injection attacks. 3. **Log** every tool invocation for auditability. 4. **Retry** or fallback when a tool fails. Below is a minimal example of a function-calling handler in Python:

```python import json import logging logging.basicConfig(level=logging.INFO) def call_tool(payload: str) -> dict: try: data = json.loads(payload) tool = data.get("tool") args = data.get("arguments", {}) logging.info("Invoking tool %s with args %s", tool, args)