462 lines
19 KiB
TypeScript
462 lines
19 KiB
TypeScript
|
// Shared Telegram-action toolkit.
|
||
|
|
// Imported by mcp/server.ts (registers each as an MCP tool) and by bot/bot.ts
|
||
|
|
// (exposes each as a Gemini function declaration and dispatches calls).
|
||
|
|
// Imports of npm packages resolve via this directory's node_modules (i.e. mcp/node_modules)
|
||
|
|
// regardless of which process loads the file.
|
||
|
|
import { z } from "zod";
|
||
|
|
import { zodToJsonSchema } from "zod-to-json-schema";
|
||
|
|
import type { Database } from "bun:sqlite";
|
||
|
|
|
||
|
|
// ---- Telegram HTTP client ----
|
||
|
|
|
||
|
|
export type TgClient = {
|
||
|
|
call: <T = unknown>(method: string, params?: Record<string, unknown>) => Promise<T>;
|
||
|
|
};
|
||
|
|
|
||
|
|
export function createTgClient(token: string): TgClient {
|
||
|
|
if (!token) throw new Error("createTgClient: empty token");
|
||
|
|
const base = `https://api.telegram.org/bot${token}`;
|
||
|
|
return {
|
||
|
|
async call<T>(method: string, params: Record<string, unknown> = {}): Promise<T> {
|
||
|
|
const res = await fetch(`${base}/${method}`, {
|
||
|
|
method: "POST",
|
||
|
|
headers: { "Content-Type": "application/json" },
|
||
|
|
body: JSON.stringify(params),
|
||
|
|
signal: AbortSignal.timeout(20_000),
|
||
|
|
});
|
||
|
|
const data = (await res.json()) as { ok: boolean; result?: T; description?: string; error_code?: number };
|
||
|
|
if (!data.ok) throw new Error(`${method}: ${data.description} (code ${data.error_code})`);
|
||
|
|
return data.result as T;
|
||
|
|
},
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- Tool context passed to every handler ----
|
||
|
|
|
||
|
|
export type ToolCtx = {
|
||
|
|
tg: TgClient;
|
||
|
|
db: Database;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- Tool definition shape ----
|
||
|
|
|
||
|
|
export type Tool<Params extends z.ZodRawShape = z.ZodRawShape> = {
|
||
|
|
name: string;
|
||
|
|
title: string;
|
||
|
|
description: string;
|
||
|
|
parameters: Params;
|
||
|
|
handler: (args: z.infer<z.ZodObject<Params>>, ctx: ToolCtx) => Promise<unknown>;
|
||
|
|
};
|
||
|
|
|
||
|
|
// ---- Shared sub-schemas ----
|
||
|
|
|
||
|
|
const chatField = z.union([z.number().int(), z.string().min(1)])
|
||
|
|
.describe("Telegram chat id (integer) OR a public @username string.");
|
||
|
|
|
||
|
|
const ParseMode = z.enum(["HTML", "MarkdownV2", "Markdown"]).optional();
|
||
|
|
|
||
|
|
const ButtonSchema = z.object({
|
||
|
|
text: z.string().min(1).max(64),
|
||
|
|
url: z.string().url().optional(),
|
||
|
|
callback_data: z.string().max(64).optional(),
|
||
|
|
copy_text: z.string().max(256).optional(),
|
||
|
|
switch_inline_query: z.string().optional(),
|
||
|
|
switch_inline_query_current_chat: z.string().optional(),
|
||
|
|
});
|
||
|
|
|
||
|
|
function buildKeyboard(rows: z.infer<typeof ButtonSchema>[][] | undefined) {
|
||
|
|
if (!rows || rows.length === 0) return undefined;
|
||
|
|
return {
|
||
|
|
inline_keyboard: rows.map((row) =>
|
||
|
|
row.map((b) => {
|
||
|
|
const out: Record<string, unknown> = { text: b.text };
|
||
|
|
if (b.url) out.url = b.url;
|
||
|
|
if (b.callback_data) out.callback_data = b.callback_data;
|
||
|
|
if (b.copy_text) out.copy_text = { text: b.copy_text };
|
||
|
|
if (b.switch_inline_query !== undefined) out.switch_inline_query = b.switch_inline_query;
|
||
|
|
if (b.switch_inline_query_current_chat !== undefined) out.switch_inline_query_current_chat = b.switch_inline_query_current_chat;
|
||
|
|
return out;
|
||
|
|
}),
|
||
|
|
),
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
// ---- The tool catalog ----
|
||
|
|
|
||
|
|
// Helper to keep the array strictly typed without losing each tool's specific param shape.
|
||
|
|
function tool<P extends z.ZodRawShape>(t: Tool<P>): Tool<z.ZodRawShape> {
|
||
|
|
return t as Tool<z.ZodRawShape>;
|
||
|
|
}
|
||
|
|
|
||
|
|
export const telegramTools: Tool<z.ZodRawShape>[] = [
|
||
|
|
// ---- discovery ----
|
||
|
|
tool({
|
||
|
|
name: "tg_me",
|
||
|
|
title: "Bot identity",
|
||
|
|
description: "Return basic info about the bot — id, username, name, capability flags.",
|
||
|
|
parameters: {},
|
||
|
|
handler: async (_a, { tg }) => tg.call("getMe"),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_resolve_chat",
|
||
|
|
title: "Resolve a user to a DM chat id",
|
||
|
|
description: "Look up a user in users.db and return their telegram_id (== their DM chat_id). Provide exactly one of telegram_id, minecraft_name, telegram_username.",
|
||
|
|
parameters: {
|
||
|
|
telegram_id: z.number().int().optional(),
|
||
|
|
minecraft_name: z.string().optional(),
|
||
|
|
telegram_username: z.string().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ telegram_id, minecraft_name, telegram_username }, { db }) => {
|
||
|
|
const n = [telegram_id, minecraft_name, telegram_username].filter((v) => v !== undefined).length;
|
||
|
|
if (n !== 1) throw new Error("Provide exactly one of telegram_id, minecraft_name, telegram_username.");
|
||
|
|
const sql = "SELECT telegram_id, name, role, minecraft_name, username, status FROM users WHERE " +
|
||
|
|
(telegram_id !== undefined ? "telegram_id = ?"
|
||
|
|
: minecraft_name !== undefined ? "minecraft_name = ?"
|
||
|
|
: "username = ?");
|
||
|
|
const arg = telegram_id ?? minecraft_name ?? telegram_username!.replace(/^@/, "");
|
||
|
|
const row = db.prepare(sql).get(arg) as { telegram_id: number } | undefined;
|
||
|
|
if (!row) throw new Error("Not found in users table.");
|
||
|
|
return { chat_id: row.telegram_id, user: row };
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_known_chats",
|
||
|
|
title: "Known chats",
|
||
|
|
description: "List chat_ids the bot has ever sent or received a message in — find group chat_ids here.",
|
||
|
|
parameters: {},
|
||
|
|
handler: async (_a, { db }) => ({
|
||
|
|
chats: db.prepare(
|
||
|
|
"SELECT chat_id, COUNT(*) AS n, MAX(created_at) AS last_at FROM messages GROUP BY chat_id ORDER BY last_at DESC",
|
||
|
|
).all(),
|
||
|
|
}),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_get_chat",
|
||
|
|
title: "Get chat info",
|
||
|
|
description: "Telegram getChat — full info about a chat (type, title, description, photo, member count for groups).",
|
||
|
|
parameters: { chat: chatField },
|
||
|
|
handler: async ({ chat }, { tg }) => tg.call("getChat", { chat_id: chat }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_get_chat_admins",
|
||
|
|
title: "List chat admins",
|
||
|
|
description: "Telegram getChatAdministrators — list admin members of a group/supergroup/channel.",
|
||
|
|
parameters: { chat: chatField },
|
||
|
|
handler: async ({ chat }, { tg }) => tg.call("getChatAdministrators", { chat_id: chat }),
|
||
|
|
}),
|
||
|
|
|
||
|
|
// ---- messaging ----
|
||
|
|
tool({
|
||
|
|
name: "tg_send_message",
|
||
|
|
title: "Send a text message",
|
||
|
|
description: "sendMessage. Supports HTML/Markdown, quote-replies, silent sends, link-preview suppression, and inline keyboards.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
text: z.string().min(1).max(4096),
|
||
|
|
parse_mode: ParseMode,
|
||
|
|
reply_to_message_id: z.number().int().optional(),
|
||
|
|
disable_notification: z.boolean().optional(),
|
||
|
|
disable_link_preview: z.boolean().optional(),
|
||
|
|
protect_content: z.boolean().optional(),
|
||
|
|
buttons: z.array(z.array(ButtonSchema)).optional(),
|
||
|
|
message_thread_id: z.number().int().optional(),
|
||
|
|
},
|
||
|
|
handler: async (a, { tg }) => {
|
||
|
|
const p: Record<string, unknown> = {
|
||
|
|
chat_id: a.chat, text: a.text, parse_mode: a.parse_mode,
|
||
|
|
disable_notification: a.disable_notification, protect_content: a.protect_content,
|
||
|
|
message_thread_id: a.message_thread_id,
|
||
|
|
};
|
||
|
|
if (a.reply_to_message_id !== undefined) p.reply_parameters = { message_id: a.reply_to_message_id };
|
||
|
|
if (a.disable_link_preview) p.link_preview_options = { is_disabled: true };
|
||
|
|
const kb = buildKeyboard(a.buttons);
|
||
|
|
if (kb) p.reply_markup = kb;
|
||
|
|
return tg.call("sendMessage", p);
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_edit_message",
|
||
|
|
title: "Edit a message",
|
||
|
|
description: "editMessageText — replace text + keyboard of a previously-sent message.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
message_id: z.number().int(),
|
||
|
|
text: z.string().min(1).max(4096),
|
||
|
|
parse_mode: ParseMode,
|
||
|
|
disable_link_preview: z.boolean().optional(),
|
||
|
|
buttons: z.array(z.array(ButtonSchema)).optional(),
|
||
|
|
},
|
||
|
|
handler: async (a, { tg }) => {
|
||
|
|
const p: Record<string, unknown> = { chat_id: a.chat, message_id: a.message_id, text: a.text, parse_mode: a.parse_mode };
|
||
|
|
if (a.disable_link_preview) p.link_preview_options = { is_disabled: true };
|
||
|
|
const kb = buildKeyboard(a.buttons);
|
||
|
|
if (kb) p.reply_markup = kb;
|
||
|
|
return tg.call("editMessageText", p);
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_delete_message",
|
||
|
|
title: "Delete a message",
|
||
|
|
description: "deleteMessage. Bots can always delete their own messages; others require admin rights.",
|
||
|
|
parameters: { chat: chatField, message_id: z.number().int() },
|
||
|
|
handler: async ({ chat, message_id }, { tg }) => ({ deleted: await tg.call("deleteMessage", { chat_id: chat, message_id }) }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_pin_message",
|
||
|
|
title: "Pin a message",
|
||
|
|
description: "pinChatMessage. Needs admin rights in groups.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
message_id: z.number().int(),
|
||
|
|
disable_notification: z.boolean().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ chat, message_id, disable_notification }, { tg }) =>
|
||
|
|
({ pinned: await tg.call("pinChatMessage", { chat_id: chat, message_id, disable_notification }) }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_unpin_message",
|
||
|
|
title: "Unpin a message",
|
||
|
|
description: "unpinChatMessage. Omit message_id to unpin the most recent pin.",
|
||
|
|
parameters: { chat: chatField, message_id: z.number().int().optional() },
|
||
|
|
handler: async ({ chat, message_id }, { tg }) =>
|
||
|
|
({ unpinned: await tg.call("unpinChatMessage", { chat_id: chat, message_id }) }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_forward_message",
|
||
|
|
title: "Forward a message",
|
||
|
|
description: "forwardMessage — relay a message between chats, preserving original author attribution.",
|
||
|
|
parameters: {
|
||
|
|
from_chat: chatField,
|
||
|
|
to_chat: chatField,
|
||
|
|
message_id: z.number().int(),
|
||
|
|
disable_notification: z.boolean().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ from_chat, to_chat, message_id, disable_notification }, { tg }) =>
|
||
|
|
tg.call("forwardMessage", { from_chat_id: from_chat, chat_id: to_chat, message_id, disable_notification }),
|
||
|
|
}),
|
||
|
|
|
||
|
|
// ---- interactivity ----
|
||
|
|
tool({
|
||
|
|
name: "tg_chat_action",
|
||
|
|
title: "Show a busy indicator",
|
||
|
|
description: "sendChatAction — show 'typing…' or similar for ~5s. Re-call to extend.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
action: z.enum([
|
||
|
|
"typing", "upload_photo", "record_video", "upload_video", "record_voice", "upload_voice",
|
||
|
|
"upload_document", "choose_sticker", "find_location", "record_video_note", "upload_video_note",
|
||
|
|
]),
|
||
|
|
message_thread_id: z.number().int().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ chat, action, message_thread_id }, { tg }) =>
|
||
|
|
({ shown: await tg.call("sendChatAction", { chat_id: chat, action, message_thread_id }) }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_react",
|
||
|
|
title: "React to a message",
|
||
|
|
description: "setMessageReaction — attach emoji reactions or clear them by passing emojis=[].",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
message_id: z.number().int(),
|
||
|
|
emojis: z.array(z.string().min(1).max(8)).max(11)
|
||
|
|
.describe("Emoji to apply. Pass [] to clear all reactions."),
|
||
|
|
is_big: z.boolean().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ chat, message_id, emojis, is_big }, { tg }) => {
|
||
|
|
const reaction = emojis.map((e) => ({ type: "emoji" as const, emoji: e }));
|
||
|
|
return { reacted: await tg.call("setMessageReaction", { chat_id: chat, message_id, reaction, is_big }) };
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_send_poll",
|
||
|
|
title: "Send a poll",
|
||
|
|
description: "sendPoll — regular or quiz-style. For quiz, set type='quiz' and correct_option_id (0-based).",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
question: z.string().min(1).max(300),
|
||
|
|
options: z.array(z.string().min(1).max(100)).min(2).max(12),
|
||
|
|
type: z.enum(["regular", "quiz"]).default("regular"),
|
||
|
|
is_anonymous: z.boolean().default(true),
|
||
|
|
allows_multiple_answers: z.boolean().optional(),
|
||
|
|
correct_option_id: z.number().int().min(0).optional(),
|
||
|
|
explanation: z.string().max(200).optional(),
|
||
|
|
open_period: z.number().int().min(5).max(600).optional(),
|
||
|
|
},
|
||
|
|
handler: async (a, { tg }) => tg.call("sendPoll", {
|
||
|
|
chat_id: a.chat, question: a.question,
|
||
|
|
options: a.options.map((text) => ({ text })),
|
||
|
|
type: a.type, is_anonymous: a.is_anonymous,
|
||
|
|
allows_multiple_answers: a.allows_multiple_answers,
|
||
|
|
correct_option_id: a.correct_option_id,
|
||
|
|
explanation: a.explanation, open_period: a.open_period,
|
||
|
|
}),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_send_dice",
|
||
|
|
title: "Send a dice / slot / dart",
|
||
|
|
description: "sendDice — animated random emoji. Telegram decides the outcome; check result.dice.value.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
emoji: z.enum(["🎲", "🎯", "🏀", "⚽", "🎳", "🎰"]).default("🎲"),
|
||
|
|
},
|
||
|
|
handler: async ({ chat, emoji }, { tg }) => tg.call("sendDice", { chat_id: chat, emoji }),
|
||
|
|
}),
|
||
|
|
|
||
|
|
// ---- rich content ----
|
||
|
|
tool({
|
||
|
|
name: "tg_send_photo",
|
||
|
|
title: "Send a photo",
|
||
|
|
description: "sendPhoto — pass an HTTPS URL Telegram can fetch, or a previously-uploaded file_id.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
photo: z.string().min(1).describe("HTTPS URL or Telegram file_id."),
|
||
|
|
caption: z.string().max(1024).optional(),
|
||
|
|
parse_mode: ParseMode,
|
||
|
|
has_spoiler: z.boolean().optional(),
|
||
|
|
disable_notification: z.boolean().optional(),
|
||
|
|
reply_to_message_id: z.number().int().optional(),
|
||
|
|
buttons: z.array(z.array(ButtonSchema)).optional(),
|
||
|
|
},
|
||
|
|
handler: async (a, { tg }) => {
|
||
|
|
const p: Record<string, unknown> = {
|
||
|
|
chat_id: a.chat, photo: a.photo, caption: a.caption,
|
||
|
|
parse_mode: a.parse_mode, has_spoiler: a.has_spoiler, disable_notification: a.disable_notification,
|
||
|
|
};
|
||
|
|
if (a.reply_to_message_id !== undefined) p.reply_parameters = { message_id: a.reply_to_message_id };
|
||
|
|
const kb = buildKeyboard(a.buttons);
|
||
|
|
if (kb) p.reply_markup = kb;
|
||
|
|
return tg.call("sendPhoto", p);
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_send_sticker",
|
||
|
|
title: "Send a sticker",
|
||
|
|
description: "sendSticker — pass a sticker file_id (see tg_stickers_known).",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
file_id: z.string().min(1),
|
||
|
|
reply_to_message_id: z.number().int().optional(),
|
||
|
|
disable_notification: z.boolean().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ chat, file_id, reply_to_message_id, disable_notification }, { tg }) => {
|
||
|
|
const p: Record<string, unknown> = { chat_id: chat, sticker: file_id, disable_notification };
|
||
|
|
if (reply_to_message_id !== undefined) p.reply_parameters = { message_id: reply_to_message_id };
|
||
|
|
return tg.call("sendSticker", p);
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_stickers_known",
|
||
|
|
title: "List bot-bound stickers",
|
||
|
|
description: "Return event→file_id mappings the bot stored via /setsticker.",
|
||
|
|
parameters: {},
|
||
|
|
handler: async (_a, { db }) => {
|
||
|
|
const rows = db.prepare("SELECT event, file_id FROM stickers ORDER BY event").all();
|
||
|
|
return { count: rows.length, stickers: rows };
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
|
||
|
|
// ---- forum topics ----
|
||
|
|
tool({
|
||
|
|
name: "tg_create_topic",
|
||
|
|
title: "Create a forum topic",
|
||
|
|
description: "createForumTopic — only in forum-mode supergroups. Returns message_thread_id.",
|
||
|
|
parameters: {
|
||
|
|
chat: chatField,
|
||
|
|
name: z.string().min(1).max(128),
|
||
|
|
icon_color: z.number().int().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ chat, name, icon_color }, { tg }) =>
|
||
|
|
tg.call("createForumTopic", { chat_id: chat, name, icon_color }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_close_topic",
|
||
|
|
title: "Close a forum topic",
|
||
|
|
description: "closeForumTopic.",
|
||
|
|
parameters: { chat: chatField, message_thread_id: z.number().int() },
|
||
|
|
handler: async ({ chat, message_thread_id }, { tg }) =>
|
||
|
|
({ closed: await tg.call("closeForumTopic", { chat_id: chat, message_thread_id }) }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_reopen_topic",
|
||
|
|
title: "Reopen a forum topic",
|
||
|
|
description: "reopenForumTopic.",
|
||
|
|
parameters: { chat: chatField, message_thread_id: z.number().int() },
|
||
|
|
handler: async ({ chat, message_thread_id }, { tg }) =>
|
||
|
|
({ reopened: await tg.call("reopenForumTopic", { chat_id: chat, message_thread_id }) }),
|
||
|
|
}),
|
||
|
|
|
||
|
|
// ---- bot config ----
|
||
|
|
tool({
|
||
|
|
name: "tg_set_chat_title",
|
||
|
|
title: "Set a chat title",
|
||
|
|
description: "setChatTitle — requires bot admin rights.",
|
||
|
|
parameters: { chat: chatField, title: z.string().min(1).max(128) },
|
||
|
|
handler: async ({ chat, title }, { tg }) =>
|
||
|
|
({ updated: await tg.call("setChatTitle", { chat_id: chat, title }) }),
|
||
|
|
}),
|
||
|
|
tool({
|
||
|
|
name: "tg_set_my_commands",
|
||
|
|
title: "Set the bot's slash-command menu",
|
||
|
|
description: "setMyCommands. Scope=default for the global menu; pass `chat` for a single chat.",
|
||
|
|
parameters: {
|
||
|
|
commands: z.array(z.object({
|
||
|
|
command: z.string().min(1).max(32),
|
||
|
|
description: z.string().min(1).max(256),
|
||
|
|
})).min(0).max(100),
|
||
|
|
scope: z.enum([
|
||
|
|
"default", "all_private_chats", "all_group_chats", "all_chat_administrators",
|
||
|
|
]).optional(),
|
||
|
|
chat: chatField.optional(),
|
||
|
|
language_code: z.string().optional(),
|
||
|
|
},
|
||
|
|
handler: async ({ commands, scope, chat, language_code }, { tg }) => {
|
||
|
|
const p: Record<string, unknown> = { commands, language_code };
|
||
|
|
if (chat !== undefined) p.scope = { type: scope === "all_chat_administrators" ? "chat_administrators" : "chat", chat_id: chat };
|
||
|
|
else if (scope) p.scope = { type: scope };
|
||
|
|
return { updated: await tg.call("setMyCommands", p) };
|
||
|
|
},
|
||
|
|
}),
|
||
|
|
];
|
||
|
|
|
||
|
|
// ---- JSON Schema conversion for Gemini function declarations ----
|
||
|
|
|
||
|
|
// Gemini's parameters block accepts a JSON-Schema-ish dialect. zod-to-json-schema
|
||
|
|
// emits JSON-Schema draft-07; the field shapes we use (string/integer/number/boolean/array/object/enum)
|
||
|
|
// pass through unchanged. We strip `$schema` since Gemini ignores it.
|
||
|
|
function cleanForGemini(s: unknown): unknown {
|
||
|
|
if (Array.isArray(s)) return s.map(cleanForGemini);
|
||
|
|
if (s && typeof s === "object") {
|
||
|
|
const out: Record<string, unknown> = {};
|
||
|
|
for (const [k, v] of Object.entries(s as Record<string, unknown>)) {
|
||
|
|
if (k === "$schema" || k === "additionalProperties" || k === "default") continue;
|
||
|
|
// Gemini doesn't accept `union/anyOf` for chat fields — flatten to "string" for compatibility.
|
||
|
|
if (k === "anyOf" || k === "oneOf") {
|
||
|
|
// Pick the first non-null subtype heuristically.
|
||
|
|
const variants = (v as unknown[]).filter((x) => x && (x as Record<string, unknown>).type !== "null");
|
||
|
|
if (variants.length === 1) return cleanForGemini(variants[0]);
|
||
|
|
// For mixed types we fall back to string.
|
||
|
|
return { type: "string" };
|
||
|
|
}
|
||
|
|
out[k] = cleanForGemini(v);
|
||
|
|
}
|
||
|
|
return out;
|
||
|
|
}
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
|
||
|
|
export function toolToGeminiFunction(t: Tool<z.ZodRawShape>) {
|
||
|
|
// Gemini's schema dialect rejects $ref/$defs/$schema/additionalProperties, so:
|
||
|
|
// - $refStrategy "none" inlines shared sub-schemas (e.g. ButtonSchema reused across tools).
|
||
|
|
// - cleanForGemini strips the rest.
|
||
|
|
const schema = zodToJsonSchema(z.object(t.parameters), {
|
||
|
|
$refStrategy: "none",
|
||
|
|
target: "openApi3",
|
||
|
|
});
|
||
|
|
const params = cleanForGemini(schema) as Record<string, unknown>;
|
||
|
|
return {
|
||
|
|
name: t.name,
|
||
|
|
description: t.description,
|
||
|
|
parameters: params.type ? params : { type: "object", properties: {} },
|
||
|
|
};
|
||
|
|
}
|