Tools, Structured Output and Agents

import json
import os

import jsonschema
import requests

API_URL = "https://platform.ai.gloo.com/ai/v2/direct/chat/completions"
HEADERS = {"Authorization": f"Bearer {os.environ['GLOO_API_KEY']}"}
MODEL = "gloo-openai-gpt-6-luna"
MAX_STEPS = 8

SERVICE_TIMES_SCHEMA = {
    "type": "object",
    "properties": {"day": {"type": "string", "enum": ["saturday", "sunday"]}},
    "required": ["day"],
    "additionalProperties": False,
}


def get_service_times(day: str) -> dict:
    return {"day": day, "times": ["9:00", "11:00"]}


TOOLS = {
    "get_service_times": {
        "schema": SERVICE_TIMES_SCHEMA,
        "run": get_service_times,
        "description": "Get this church's service times for a weekend day.",
    },
}


def run_tool(call: dict) -> str:
    """Run one tool call and return its result as a string, including errors the model can fix."""
    tool = TOOLS.get(call["function"]["name"])
    if tool is None:
        return json.dumps({"error": f"Unknown tool {call['function']['name']}"})
    try:
        args = json.loads(call["function"]["arguments"] or "{}")
        jsonschema.validate(args, tool["schema"])
    except (json.JSONDecodeError, jsonschema.ValidationError) as err:
        return json.dumps({"error": f"Invalid arguments: {err}"})
    return json.dumps(tool["run"](**args))


def answer(question: str) -> str:
    messages = [{"role": "user", "content": question}]
    tools = [
        {"type": "function", "function": {"name": name, "description": t["description"], "parameters": t["schema"]}}
        for name, t in TOOLS.items()
    ]
    for _ in range(MAX_STEPS):
        r = requests.post(API_URL, headers=HEADERS, timeout=120, json={
            "model": MODEL, "messages": messages, "tools": tools, "max_tokens": 16384,
        })
        r.raise_for_status()
        message = r.json()["choices"][0]["message"]
        calls = message.get("tool_calls") or []
        if not calls:
            return message.get("content") or ""
        messages.append({"role": "assistant", "content": message.get("content"), "tool_calls": calls})
        for call in calls:
            messages.append({"role": "tool", "tool_call_id": call["id"], "content": run_tool(call)})
    raise RuntimeError(f"No answer after {MAX_STEPS} steps")

const API_URL = "https://platform.ai.gloo.com/ai/v2/direct/chat/completions";
const HEADERS = {
  Authorization: `Bearer ${process.env.GLOO_API_KEY}`,
  "Content-Type": "application/json",
};
const MODEL = "gloo-openai-gpt-6-luna";
const MAX_STEPS = 8;

type ToolCall = { id: string; function: { name: string; arguments: string } };

const TOOLS: Record<string, { description: string; parameters: object; run: (args: any) => unknown; check: (args: any) => string | null }> = {
  get_service_times: {
    description: "Get this church's service times for a weekend day.",
    parameters: {
      type: "object",
      properties: { day: { type: "string", enum: ["saturday", "sunday"] } },
      required: ["day"],
      additionalProperties: false,
    },
    check: (args) => {
      if (typeof args !== "object" || args === null || Array.isArray(args)) return "arguments must be an object";
      const extra = Object.keys(args).filter((key) => key !== "day");
      if (extra.length > 0) return `unexpected properties: ${extra.join(", ")}`;
      return ["saturday", "sunday"].includes(args.day) ? null : "day must be saturday or sunday";
    },
    run: (args) => ({ day: args.day, times: ["9:00", "11:00"] }),
  },
};

/** Run one tool call and return its result as a string, including errors the model can fix. */
function runTool(call: ToolCall): string {
  const tool = Object.hasOwn(TOOLS, call.function.name) ? TOOLS[call.function.name] : undefined;
  if (!tool) return JSON.stringify({ error: `Unknown tool ${call.function.name}` });
  let args: unknown;
  try {
    args = JSON.parse(call.function.arguments || "{}");
  } catch {
    return JSON.stringify({ error: "Arguments were not valid JSON" });
  }
  const problem = tool.check(args);
  if (problem) return JSON.stringify({ error: `Invalid arguments: ${problem}` });
  return JSON.stringify(tool.run(args));
}

async function answer(question: string): Promise<string> {
  const messages: any[] = [{ role: "user", content: question }];
  const tools = Object.entries(TOOLS).map(([name, t]) => ({
    type: "function",
    function: { name, description: t.description, parameters: t.parameters },
  }));
  for (let step = 0; step < MAX_STEPS; step++) {
    const res = await fetch(API_URL, {
      method: "POST",
      headers: HEADERS,
      body: JSON.stringify({ model: MODEL, messages, tools, max_tokens: 16384 }),
    });
    if (!res.ok) throw new Error(`Request failed: ${res.status} ${await res.text()}`);
    const message = (await res.json()).choices[0].message;
    const calls: ToolCall[] = message.tool_calls ?? [];
    if (calls.length === 0) return message.content ?? "";
    messages.push({ role: "assistant", content: message.content ?? null, tool_calls: calls });
    for (const call of calls) {
      messages.push({ role: "tool", tool_call_id: call.id, content: runTool(call) });
    }
  }
  throw new Error(`No answer after ${MAX_STEPS} steps`);
}