Run the tools on your backend

def search(query: str, limit: int = 5) -> list[dict]:
    """Semantic search over your corpus."""
    docs = semantic_index.search(query=query, limit=limit)  # turbopuffer ANN, Postgres pgvector, etc.
    return [{"id": d.id, "title": d.title, "content": d.snippet} for d in docs]


def text_search(query: str, limit: int = 5) -> list[dict]:
    """Lexical search over the same corpus."""
    docs = full_text_index.search(query=query, limit=limit)  # BM25, Postgres tsvector, Elastic, etc.
    return [{"id": d.id, "title": d.title, "content": d.snippet} for d in docs]

async function search(query: string, limit = 5): Promise<Record<string, unknown>[]> {
  // Semantic search over your corpus.
  const docs = await semanticIndex.search({ query, limit }); // turbopuffer ANN, Postgres pgvector, etc.
  return docs.map((d) => ({ id: d.id, title: d.title, content: d.snippet }));
}

async function textSearch(query: string, limit = 5): Promise<Record<string, unknown>[]> {
  // Lexical search over the same corpus.
  const docs = await fullTextIndex.search({ query, limit }); // BM25, Postgres tsvector, Elastic, etc.
  return docs.map((d) => ({ id: d.id, title: d.title, content: d.snippet }));
}

def search(query: str, limit: int = 5) -> list[dict]:
    rows = my_index.query(query, limit=limit)
    return [
        {
            "id": row.pk,          # your stable identifier
            "title": row.heading,  # whatever you want SID-1 to see as a title
            "content": row.body,   # the snippet to show (see below)
        }
        for row in rows
    ]

async function search(query: string, limit = 5): Promise<Record<string, unknown>[]> {
  const rows = await myIndex.query(query, limit);
  return rows.map((row) => ({
    id: row.pk,         // your stable identifier
    title: row.heading, // whatever you want SID-1 to see as a title
    content: row.body,  // the snippet to show (see below)
  }));
}

def read(id: str) -> dict:
    doc = document_store.get(id)
    return {
        "id": doc.id,
        "title": doc.title,
        "content": truncate_to_tokens(doc.content, max_tokens=3000),
    }

async function read(id: string): Promise<Record<string, unknown>> {
  const doc = await documentStore.get(id);
  return { id: doc.id, title: doc.title, content: truncateToTokens(doc.content, 3000) };
}

import json

NO_RESULTS = "No documents matched this query. Try different keywords, synonyms, or a broader search."
SEARCH_FAILED = "This search timed out before returning results. Try again or use a simpler query."


def run_search(fn, query: str, limit: int) -> str:
    try:
        docs = fn(query, limit)  # set a timeout on your backend call
    except Exception:  # your backend's timeout or connection error
        return SEARCH_FAILED
    return format_docs_xml(docs) if docs else NO_RESULTS


tool_messages = []

for tc in assistant_msg.tool_calls:
    name = tc.function.name
    args = json.loads(tc.function.arguments)

    if name == "search":
        content = run_search(search, args["query"], args.get("limit", 5))
    elif name == "text_search":
        content = run_search(text_search, args["query"], args.get("limit", 5))
    elif name == "read":
        content = format_docs_xml([read(args["id"])])
    else:
        content = f"Unknown tool: {name}"

    tool_messages.append(
        {
            "role": "tool",
            "tool_call_id": tc.id,
            "content": content,
        }
    )

messages.extend(tool_messages)

const NO_RESULTS = "No documents matched this query. Try different keywords, synonyms, or a broader search.";
const SEARCH_FAILED = "This search timed out before returning results. Try again or use a simpler query.";

async function runSearch(
  fn: (query: string, limit: number) => Promise<Record<string, unknown>[]>,
  query: string,
  limit: number,
): Promise<string> {
  let docs: Record<string, unknown>[];
  try {
    docs = await fn(query, limit); // set a timeout on your backend call
  } catch {
    return SEARCH_FAILED; // your backend's timeout or connection error
  }
  return docs.length ? formatDocsXml(docs) : NO_RESULTS;
}

const toolMessages: OpenAI.Chat.Completions.ChatCompletionToolMessageParam[] = [];

for (const tc of assistantMsg.tool_calls ?? []) {
  const name = tc.function.name;
  const args = JSON.parse(tc.function.arguments);

  let content: string;
  if (name === "search") {
    content = await runSearch(search, args.query, args.limit ?? 5);
  } else if (name === "text_search") {
    content = await runSearch(textSearch, args.query, args.limit ?? 5);
  } else if (name === "read") {
    content = formatDocsXml([await read(args.id)]);
  } else {
    content = `Unknown tool: ${name}`;
  }

  toolMessages.push({
    role: "tool",
    tool_call_id: tc.id,
    content,
  });
}

messages.push(...toolMessages);

# Add focused metadata fields when they help SID-1 judge relevance.
def text_search(query: str, limit: int = 5) -> list[dict]:
    rows = my_index.query(query, limit=limit)
    return [
        {
            "id": r.pk,
            "title": r.heading,
            "content": r.body,
            "published_at": r.published_at,
            "author": r.author,
        }
        for r in rows
    ]


def format_docs_xml(docs: list[dict]) -> str:
    parts = []
    for doc in docs:
        parts.append(
            f'<doc id="{doc["id"]}" title="{doc["title"]}" '
            f'published_at="{doc["published_at"]}" author="{doc["author"]}">\n'
            f'{doc["content"]}\n'
            "</doc>"
        )
    return "\n".join(parts)

// Add focused metadata fields when they help SID-1 judge relevance.
async function textSearch(query: string, limit = 5): Promise<Record<string, unknown>[]> {
  const rows = await myIndex.query(query, limit);
  return rows.map((r) => ({
    id: r.pk,
    title: r.heading,
    content: r.body,
    published_at: r.publishedAt,
    author: r.author,
  }));
}

function formatDocsXml(docs: Record<string, unknown>[]): string {
  return docs
    .map(
      (doc) =>
        `<doc id="${doc.id ?? ""}" title="${doc.title ?? ""}" published_at="${doc.published_at ?? ""}" author="${doc.author ?? ""}">\n${doc.content ?? ""}\n</doc>`,
    )
    .join("\n");
}