GitHub Copilot SDK tools are called with empty params {} when querying Prometheus / Loki

[Haddajii]

I’m building an SRE-style assistant using GitHub Copilot SDK (Python) with tool calling.

Context

• Infrastructure: OpenStack (controller, compute, storage nodes)
• Monitoring node runs:
  • Prometheus (metrics from other nodes)
  • Loki + Promtail (logs from other nodes)
  • Grafana (everything works fine)
• I’m running my Copilot SDK + FastAPI app on the monitoring node

What I’m trying to do

I defined tools using @define_tool so the AI can:

• Query Prometheus for metrics
• Query Loki for logs
• Act like an SRE (e.g. “check CPU usage”, “show error logs for nova”)

code

from copilot.tools import define_tool
import requests

LOKI_URL = "http://localhost:3100/loki/api/v1/query"

@define_tool(
    description="Query Loki logs using LogQL. Use this to fetch logs from OpenStack nodes."
)
async def query_loki(query: str, limit: int = 50) -> dict:
    print("[TOOL] Loki called with:", query, limit)

    try:
        response = requests.get(
            LOKI_URL,
            params={"query": query, "limit": limit},
            timeout=5
        )
        data = response.json()

        logs = []
        for stream in data.get("data", {}).get("result", []):
            for value in stream.get("values", []):
                logs.append(value[1])

        return {
            "query": query,
            "log_count": len(logs),
            "logs": logs[:limit]
        }

    except Exception as e:
        return {"error": str(e)}

Problem

When I ask the AI something like:

"Show me recent error logs from compute nodes"
The tool does get called, but:

loki called with param: {}

so:

• The model decides to call the tool
• But it passes empty parameters
• Result: no logs, no metrics

What I’ve verified

• Prometheus endpoints work via browser & curl
• localhost is correct (everything runs on the monitoring node)
• Streaming responses are enabled

Questions

• How do I force or strongly guide Copilot SDK to send required parameters to tools?
• Is there a recommended way to define tool schemas so params are never empty?
• Is this expected behavior with Copilot SDK tool calling?
• Any best practices for building observability / SRE agents with Copilot SDK?

[luigiscofano]

There are two separate issues in the Loki example: the tool’s parameter schema and the Loki endpoint.

With github-copilot-sdk==1.0.28, the Python @define_tool decorator infers the schema from a Pydantic parameter model. Your signature, query_loki(query: str, limit: int = 50), produces parameters=None. The decorator also treats a second function parameter as the tool invocation context, so limit does not behave as intended.

Use a single parameter model:

import httpx
from copilot.tools import define_tool
from pydantic import BaseModel, Field


class LokiParams(BaseModel):
    query: str = Field(
        min_length=1,
        description="LogQL log query using actual Loki labels",
    )
    limit: int = Field(default=50, ge=1, le=1000)


@define_tool(
    description="Fetch recent Loki log lines using a LogQL log query."
)
async def query_loki(params: LokiParams) -> dict:
    async with httpx.AsyncClient(timeout=5.0) as client:
        response = await client.get(
            "http://localhost:3100/loki/api/v1/query_range",
            params={"query": params.query, "limit": params.limit},
        )
        response.raise_for_status()
        data = response.json()["data"]

    if data["resultType"] != "streams":
        raise ValueError(
            "Expected a LogQL log query, not a metric query."
        )

    logs = [
        value[1]
        for stream in data["result"]
        for value in stream["values"]
    ]
    return {
        "query": params.query,
        "log_count": len(logs),
        "logs": logs,
    }

Register this updated tool in your session’s tools list. You can inspect query_loki.parameters: its required list should contain "query", while limit defaults to 50.

This gives the model an explicit schema and rejects missing query arguments before making an HTTP request. It does not guarantee that the model will always generate valid arguments or valid LogQL; provide the actual label names and values available in your Loki deployment.

For log lines, use /loki/api/v1/query_range. Loki’s instant /query endpoint rejects log-type queries. Without explicit start and end, the range defaults to the last hour. raise_for_status() also prevents an HTTP error from being mistaken for a successful empty result.

References: Python SDK tools and Loki HTTP API.

Validation: local checks with SDK 1.0.28 and mocked HTTP confirmed schema generation, rejection of missing arguments, successful log extraction, and failure handling for HTTP errors. This was not tested against a live Copilot session or Loki deployment; the original post does not specify its SDK version.