Tool calling

npm install caesar-search

import { Caesar } from "caesar-search";

const caesar = new Caesar(); // reads CAESAR_API_KEY

export const caesarTools = [
  {
    name: "web_search",
    description: "Search the web with Caesar and return ranked results with doc_id values.",
    input_schema: {
      type: "object",
      properties: {
        query: { type: "string" },
        max_results: { type: "integer", minimum: 1, maximum: 50 },
        response_format: { type: "string", enum: ["compact", "standard", "full"] },
      },
      required: ["query"],
    },
  },
  {
    name: "web_fetch",
    description: "Read a Caesar doc_id or URL as clean markdown.",
    input_schema: {
      type: "object",
      properties: {
        target: { type: "string" },
        query: { type: "string" },
        max_chars: { type: "integer", minimum: 1, maximum: 50000 },
        start_char: { type: "integer", minimum: 0 },
      },
      required: ["target"],
    },
  },
];

export async function runCaesarToolCall(call: {
  name: string;
  input: Record<string, unknown>;
}) {
  if (call.name === "web_search") {
    const query = String(call.input.query);
    const maxResults = Number(call.input.max_results ?? 8);
    const responseFormat = String(call.input.response_format ?? "compact");

    return caesar.search(query, {
      maxResults,
      verbosity: responseFormat as "compact" | "standard" | "full",
    });
  }

  if (call.name === "web_fetch") {
    const target = String(call.input.target);
    return caesar.read(target, {
      query: call.input.query ? String(call.input.query) : undefined,
      maxChars:
        call.input.max_chars === undefined
          ? undefined
          : Number(call.input.max_chars),
      startChar: Number(call.input.start_char ?? 0),
    });
  }

  throw new Error(`unknown tool: ${call.name}`);
}

pip install caesar-search

from typing import Any

from caesar_search import Caesar

client = Caesar()  # reads CAESAR_API_KEY


def run_caesar_tool_call(name: str, arguments: dict[str, Any]) -> Any:
    if name == "web_search":
        return client.search(
            str(arguments["query"]),
            max_results=int(arguments.get("max_results", 8)),
            verbosity=str(arguments.get("response_format", "compact")),
        ).model_dump()

    if name == "web_fetch":
        max_chars = arguments.get("max_chars")
        return client.read(
            str(arguments["target"]),
            query=arguments.get("query"),
            max_chars=int(max_chars) if max_chars is not None else None,
            start_char=int(arguments.get("start_char", 0)),
        ).model_dump()

    raise ValueError(f"unknown tool: {name}")

await caesar.feedback("result_helpful", {
  searchId: search_id,
  docId: doc_id,
});