nixamp 0.68.2 → 0.70.0

package/dist/school-client.js

@@ -0,0 +1,148 @@
+/**
+ * backtoschool.help as a client: its classes are nixamp's live events, served
+ * by the same process on another host, so one nixamp token signs in to both.
+ *
+ * The CLI (school-cli.ts) and the MCP tools (school-mcp.ts) are both this
+ * file; neither talks HTTP itself.
+ *
+ * `broadcastHealth` is the reason this exists as much as the CRUD: a class
+ * stays "live" until somebody ends it, long after the channel it points at
+ * was stopped, and the page then shows a player that never plays. It asks the
+ * broadcast itself, with only what the public link already carries.
+ */
+import { readSession } from "./session.js";
+export const SCHOOL_SITE = "https://backtoschool.help";
+export class SchoolError extends Error {
+    status;
+    constructor(message, status = 0) {
+        super(message);
+        this.status = status;
+    }
+}
+export function schoolSite(options = {}) {
+    return (options.site ?? process.env["NIXAMP_SCHOOL_URL"] ?? SCHOOL_SITE).replace(/\/+$/, "");
+}
+export function classUrl(item, options = {}) {
+    return `${schoolSite(options)}/live/${item.slug}`;
+}
+function tokenOf(options) {
+    if (options.token !== undefined)
+        return options.token;
+    return readSession()?.token ?? null;
+}
+async function call(path, init = {}, options = {}) {
+    const token = tokenOf(options);
+    if (init.auth && !token)
+        throw new SchoolError("Not signed in. Run `nixamp login`, or set NIXAMP_TOKEN.", 401);
+    const headers = { accept: "application/json" };
+    if (token)
+        headers["authorization"] = `Bearer ${token}`;
+    if (init.body !== undefined)
+        headers["content-type"] = "application/json";
+    const response = await (options.fetcher ?? fetch)(`${schoolSite(options)}${path}`, {
+        method: init.method ?? "GET",
+        headers,
+        ...(init.body === undefined ? {} : { body: JSON.stringify(init.body) }),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok)
+        throw new SchoolError(String(body["error"] ?? `backtoschool.help answered ${response.status}`), response.status);
+    return body;
+}
+const eventOf = (body) => (body["event"] ?? body);
+const ref = (value) => encodeURIComponent(value.replace(/^.*\/live\//, "").replace(/[?#].*$/, ""));
+export async function listClasses(query = {}, options = {}) {
+    const params = new URLSearchParams();
+    if (query.status)
+        params.set("status", query.status);
+    if (query.kind)
+        params.set("kind", query.kind);
+    if (query.mine)
+        params.set("mine", "true");
+    params.set("limit", String(query.limit ?? 60));
+    const body = await call(`/api/v1/events?${params}`, { auth: query.mine === true }, options);
+    return body["events"] ?? [];
+}
+/** A class by its slug, id, or the /live/<slug> link. */
+export async function getClass(slug, options = {}) {
+    return eventOf(await call(`/api/v1/events/${ref(slug)}`, {}, options));
+}
+export async function createClass(input, options = {}) {
+    return eventOf(await call("/api/v1/events", { method: "POST", body: { kind: "class", visibility: "public", ...input }, auth: true }, options));
+}
+export async function updateClass(slug, patch, options = {}) {
+    const current = await getClass(slug, options);
+    return eventOf(await call(`/api/v1/events/${ref(current.id)}`, { method: "PATCH", body: { ...patch, version: current.version }, auth: true }, options));
+}
+/** start, end, doors, encore, cancel or archive. Each wants the version it saw, so it is read first. */
+export async function moveClass(slug, action, options = {}) {
+    const current = await getClass(slug, options);
+    return eventOf(await call(`/api/v1/events/${ref(current.id)}/${action}`, { method: "POST", body: { version: current.version }, auth: true }, options));
+}
+export async function deleteClass(slug, options = {}) {
+    await call(`/api/v1/events/${ref(slug)}`, { method: "DELETE", auth: true }, options);
+}
+/** Make a class of a broadcast and put it on the air in one go. */
+export async function teach(input, options = {}) {
+    const made = await createClass(input, options);
+    return moveClass(made.slug, "start", options);
+}
+/**
+ * Does this broadcast play? true and false are answers; null is "cannot tell
+ * from here" (a Pairux room), which a prune must leave alone.
+ */
+export async function broadcastHealth(link, fetcher = fetch, timeoutMs = 8000) {
+    if (!link)
+        return { ok: false, reason: "no broadcast link" };
+    let url;
+    try {
+        url = new URL(link);
+    }
+    catch {
+        return { ok: false, reason: "not a link" };
+    }
+    const get = (target, headers = {}) => fetcher(target, { headers, signal: AbortSignal.timeout(timeoutMs) });
+    try {
+        // A station page: its own token opens its state.
+        const station = /^\/station\/([a-z0-9]{10})\/?$/.exec(url.pathname)?.[1];
+        if (station && url.hostname.endsWith(".nixamp.com")) {
+            const response = await get(`${url.origin}/api/v1/stations/${station}/state?t=${encodeURIComponent(url.searchParams.get("t") ?? "")}`);
+            if (!response.ok)
+                return { ok: false, reason: `station ${station} answered ${response.status}` };
+            const state = (await response.json());
+            return state.state === "live" ? { ok: true, reason: `station ${station} is live` } : { ok: false, reason: `station ${station} is ${state.state ?? "not live"}` };
+        }
+        // nixamp.com/?url=<server>/view/<listen key>&play=channel:<id>: the listen key reads the server's channels.
+        if ((url.hostname === "nixamp.com" || url.hostname === "www.nixamp.com") && url.searchParams.get("url")) {
+            const server = new URL(url.searchParams.get("url"));
+            const key = /\/view\/([^/?#]+)/.exec(server.pathname)?.[1] ?? "";
+            const play = url.searchParams.get("play") ?? "live";
+            const response = await get(`${server.origin}/api/streams?k=${encodeURIComponent(key)}`);
+            if (!response.ok)
+                return { ok: false, reason: `${server.host} answered ${response.status}` };
+            const streams = (await response.json());
+            if (play.startsWith("channel:")) {
+                const id = play.slice("channel:".length);
+                return (streams.channels ?? []).some((one) => one.id === id)
+                    ? { ok: true, reason: `channel ${id} is on ${server.hostname}` }
+                    : { ok: false, reason: `channel ${id} is no longer on ${server.hostname}` };
+            }
+            if (play === "live")
+                return streams.server?.live ? { ok: true, reason: `${server.hostname} is live` } : { ok: false, reason: `${server.hostname} is not live` };
+            return { ok: true, reason: `${server.hostname} is up` };
+        }
+        if (url.hostname === "pairux.com" || url.hostname === "www.pairux.com")
+            return { ok: null, reason: "a Pairux room; cannot tell from here" };
+        // Direct media: one byte is enough to know it is there.
+        const response = await get(url.href, { range: "bytes=0-0" });
+        return response.ok ? { ok: true, reason: `${url.hostname} serves it` } : { ok: false, reason: `${url.hostname} answered ${response.status}` };
+    }
+    catch (error) {
+        return { ok: false, reason: `unreachable: ${error.message}` };
+    }
+}
+/** Your live classes, each with whether its broadcast plays. */
+export async function checkClasses(options = {}, status = "live") {
+    const items = await listClasses({ mine: true, status }, options);
+    return Promise.all(items.map(async (item) => ({ item, health: await broadcastHealth(item.broadcastUrl, options.fetcher ?? fetch) })));
+}

package/dist/school-discovery.d.ts

@@ -0,0 +1,32 @@
+/**
+ * backtoschool.help's own front door for agents: llms.txt, an OpenAPI
+ * document of the class API, and MCP at /mcp/public (reading) and /mcp
+ * (teaching, as the bearer).
+ *
+ * The school is served by the nixamp process under another Host, so before
+ * this its /llms.txt and /mcp answered as nixamp.com: an agent landing on
+ * the school was told about radio stations and handed no class tools. The
+ * routes here run only for the school's host, ahead of nixamp's.
+ *
+ * The tools are school-mcp.ts, called over HTTP against the school's own
+ * origin with the caller's token, exactly as from a CLI. Sign-in is nixamp's:
+ * one account, one token, and nixamp.com is the authorization server.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+export interface SchoolDiscoveryContext {
+    /** This school's origin, e.g. https://backtoschool.help. */
+    site: string;
+    /** nixamp.com: where tokens come from and where OAuth is. */
+    accountSite: string;
+    version: string;
+    whoIs: (token: string) => Promise<unknown>;
+    token: string;
+    readBody: (request: IncomingMessage, limit: number) => Promise<string>;
+    json: (response: ServerResponse, status: number, body: unknown) => void;
+    fetcher?: typeof fetch;
+}
+/** Is this host the school? backtoschool.help (or NIXAMP_SCHOOL_URL), with or without www. */
+export declare function isSchoolSite(site: string | undefined, env?: NodeJS.ProcessEnv): boolean;
+export declare function schoolLlmsTxt(site: string, accountSite: string): string;
+export declare function schoolOpenapi(site: string, accountSite: string, version: string): Record<string, unknown>;
+export declare function handleSchoolDiscovery(request: IncomingMessage, response: ServerResponse, path: string, ctx: SchoolDiscoveryContext): Promise<boolean>;

package/dist/school-discovery.js

@@ -0,0 +1,204 @@
+import { SCHOOL_PUBLIC_TOOLS, SCHOOL_TOOLS, callSchoolTool, isSchoolPublicTool, isSchoolTool } from "./school-mcp.js";
+import { SCHOOL_SITE } from "./school-client.js";
+const CORS = {
+    "access-control-allow-origin": "*",
+    "access-control-allow-methods": "GET, POST, DELETE, OPTIONS",
+    "access-control-allow-headers": "authorization, content-type, mcp-session-id, mcp-protocol-version",
+};
+const PATHS = new Set(["/llms.txt", "/openapi.json", "/mcp", "/mcp/public", "/.well-known/oauth-protected-resource"]);
+/** Is this host the school? backtoschool.help (or NIXAMP_SCHOOL_URL), with or without www. */
+export function isSchoolSite(site, env = process.env) {
+    if (!site)
+        return false;
+    const bare = (value) => new URL(value).hostname.replace(/^www\./, "");
+    try {
+        return bare(site) === bare(env["NIXAMP_SCHOOL_URL"] ?? SCHOOL_SITE);
+    }
+    catch {
+        return false;
+    }
+}
+export function schoolLlmsTxt(site, accountSite) {
+    return `# BackToSchool.help
+
+> Live classes anybody can teach and anybody can join: a broadcast (a nixamp station, a screen share, a video link) with chat and raised hands around it. Free to watch. Accounts are nixamp accounts.
+
+## Web
+- ${site}/ : classes live now and coming up
+- ${site}/live/<slug> : one class
+
+## MCP
+- Public, no account (what is on, one class): ${site}/mcp/public
+- Signed in (teach, start, end, delete, check your classes): ${site}/mcp , a nixamp token as the bearer (\`nixamp token create\`) or OAuth via ${accountSite}
+- Local over stdio: npx -y nixamp mcp (the class tools are among nixamp's)
+
+Tools: classes_list, class_get, class_teach (a broadcast link in, a live class out), class_create, class_update, class_start, class_end, class_delete, classes_check (which of your live classes no longer play).
+
+## CLI
+- Install: curl -fsSL ${accountSite}/install.sh | sh   (or npx -y nixamp)
+- Sign in: nixamp login
+- nixamp school list --status live
+- nixamp school teach <station link> --title "..."   make a class and start it
+- nixamp school check | prune --end                 find and end classes whose broadcast stopped
+- nixamp school help
+
+## API
+- OpenAPI: ${site}/openapi.json
+- GET ${site}/api/v1/events?status=live : classes (public ones; ?mine=true with a token)
+- GET ${site}/api/v1/events/<slug> : one class
+- POST ${site}/api/v1/events : make one {title, broadcastUrl, description, topic, visibility, startsAt}
+- POST ${site}/api/v1/events/<slug>/start|end {version} : the version you last read
+- PATCH ${site}/api/v1/events/<slug> {..., version}, DELETE ${site}/api/v1/events/<slug>
+- Auth: Authorization: Bearer <nixamp token>
+
+## What a broadcast can be
+A nixamp station link (https://<server>.nixamp.com:4321/station/<id>?t=<token>), a nixamp.com share link, a Pairux room, or a direct https .m3u8/.mp4/.mp3. Only broadcast what you have the right to: your own teaching, or openly licensed courses (MIT OpenCourseWare is CC BY-NC-SA: free, credited, no ads).
+`;
+}
+export function schoolOpenapi(site, accountSite, version) {
+    const ok = { description: "OK", content: { "application/json": { schema: { type: "object" } } } };
+    const auth = { security: [{ bearer: [] }] };
+    const slug = [{ name: "slug", in: "path", required: true, schema: { type: "string" }, description: "The class's slug or id." }];
+    const versioned = { content: { "application/json": { schema: { type: "object", properties: { version: { type: "integer" } }, required: ["version"] } } } };
+    const fields = {
+        title: { type: "string", maxLength: 160 }, description: { type: "string", maxLength: 5000 }, topic: { type: "string", maxLength: 100 },
+        broadcastUrl: { type: "string", format: "uri" }, visibility: { type: "string", enum: ["public", "unlisted", "private"] },
+        startsAt: { type: "string", format: "date-time" }, chatEnabled: { type: "boolean" }, handRaiseEnabled: { type: "boolean" },
+    };
+    return {
+        openapi: "3.1.0",
+        info: { title: "BackToSchool.help", version, description: "Live classes. Reading is open; teaching wants a nixamp token as the bearer.", license: { name: "MIT", identifier: "MIT" } },
+        servers: [{ url: site }],
+        externalDocs: { description: "llms.txt: MCP, CLI and API in one place", url: `${site}/llms.txt` },
+        components: { securitySchemes: { bearer: { type: "http", scheme: "bearer", description: `A nixamp token (\`nixamp token create\`) or an OAuth access token from ${accountSite}.` } } },
+        paths: {
+            "/api/v1/events": {
+                get: {
+                    summary: "Classes", tags: ["classes"], responses: { 200: ok },
+                    parameters: [
+                        { name: "status", in: "query", schema: { type: "string", enum: ["draft", "scheduled", "starting", "live", "encore", "ended", "cancelled", "archived"] } },
+                        { name: "mine", in: "query", schema: { type: "boolean" }, description: "Only yours (needs the bearer)." },
+                        { name: "limit", in: "query", schema: { type: "integer", maximum: 100 } },
+                    ],
+                },
+                post: { summary: "Make a class (a draft; start it to go live)", tags: ["classes"], ...auth, requestBody: { content: { "application/json": { schema: { type: "object", properties: { kind: { type: "string", enum: ["class", "talk", "concert"] }, ...fields }, required: ["title"] } } } }, responses: { 200: ok } },
+            },
+            "/api/v1/events/{slug}": {
+                parameters: slug,
+                get: { summary: "One class", tags: ["classes"], responses: { 200: ok } },
+                patch: { summary: "Change a class you host", tags: ["classes"], ...auth, requestBody: { content: { "application/json": { schema: { type: "object", properties: { ...fields, version: { type: "integer" } }, required: ["version"] } } } }, responses: { 200: ok } },
+                delete: { summary: "Delete a class you host", tags: ["classes"], ...auth, responses: { 200: ok } },
+            },
+            "/api/v1/events/{slug}/start": { parameters: slug, post: { summary: "Go live", tags: ["classes"], ...auth, requestBody: versioned, responses: { 200: ok } } },
+            "/api/v1/events/{slug}/end": { parameters: slug, post: { summary: "End it", tags: ["classes"], ...auth, requestBody: versioned, responses: { 200: ok } } },
+            "/api/v1/events/{slug}/chat": { parameters: slug, get: { summary: "The class chat", tags: ["chat"], responses: { 200: ok } }, post: { summary: "Say something", tags: ["chat"], ...auth, responses: { 200: ok } } },
+            "/api/v1/auth/me": { get: { summary: "Who the bearer is", tags: ["auth"], ...auth, responses: { 200: ok } } },
+            "/mcp/public": { post: { summary: "MCP (streamable HTTP, JSON-RPC): classes_list, class_get", tags: ["mcp"], responses: { 200: ok } } },
+            "/mcp": { post: { summary: "MCP (streamable HTTP, JSON-RPC): every class tool, as the bearer", tags: ["mcp"], ...auth, responses: { 200: ok } } },
+        },
+    };
+}
+export async function handleSchoolDiscovery(request, response, path, ctx) {
+    if (!PATHS.has(path))
+        return false;
+    const method = request.method ?? "GET";
+    const site = ctx.site.replace(/\/+$/, "");
+    if (method === "OPTIONS") {
+        response.writeHead(204, CORS);
+        response.end();
+        return true;
+    }
+    if (path === "/llms.txt" || path === "/openapi.json" || path === "/.well-known/oauth-protected-resource") {
+        if (method !== "GET" && method !== "HEAD") {
+            ctx.json(response, 405, { error: "GET only" });
+            return true;
+        }
+        const [type, body] = path === "/llms.txt"
+            ? ["text/plain; charset=utf-8", schoolLlmsTxt(site, ctx.accountSite)]
+            : ["application/json; charset=utf-8", JSON.stringify(path === "/openapi.json"
+                    ? schoolOpenapi(site, ctx.accountSite, ctx.version)
+                    : { resource: site, authorization_servers: [ctx.accountSite], bearer_methods_supported: ["header"], resource_name: "BackToSchool.help" }, null, 2)];
+        response.writeHead(200, { ...CORS, "content-type": type, "cache-control": "public, max-age=300" });
+        response.end(method === "HEAD" ? undefined : body);
+        return true;
+    }
+    // MCP. GET has nothing to push; DELETE ends a session nobody keeps.
+    if (method === "GET") {
+        response.writeHead(405, { ...CORS, allow: "POST, DELETE" });
+        response.end();
+        return true;
+    }
+    if (method === "DELETE") {
+        response.writeHead(204, CORS);
+        response.end();
+        return true;
+    }
+    if (method !== "POST") {
+        ctx.json(response, 405, { error: "POST a JSON-RPC message" });
+        return true;
+    }
+    const signed = path === "/mcp";
+    if (signed && (await ctx.whoIs(ctx.token)) === null) {
+        const error = JSON.stringify({ error: "sign in: a nixamp token as the bearer (`nixamp token create`), or OAuth" });
+        response.writeHead(401, {
+            ...CORS,
+            "content-type": "application/json; charset=utf-8",
+            "www-authenticate": `Bearer resource_metadata="${site}/.well-known/oauth-protected-resource"`,
+        });
+        response.end(error);
+        return true;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(await ctx.readBody(request, 256 * 1024));
+    }
+    catch {
+        ctx.json(response, 400, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "parse error" } });
+        return true;
+    }
+    const tools = signed ? SCHOOL_TOOLS : SCHOOL_PUBLIC_TOOLS;
+    const allowed = signed ? isSchoolTool : isSchoolPublicTool;
+    const answers = [];
+    for (const message of (Array.isArray(parsed) ? parsed : [parsed])) {
+        const id = message?.id ?? null;
+        const name = typeof message?.method === "string" ? message.method : "";
+        if (name.startsWith("notifications/"))
+            continue;
+        if (name === "initialize") {
+            answers.push({ jsonrpc: "2.0", id, result: {
+                    protocolVersion: message.params?.["protocolVersion"] ?? "2025-06-18",
+                    capabilities: { tools: { listChanged: false } },
+                    serverInfo: { name: "backtoschool", title: "BackToSchool.help: live classes", version: "1" },
+                    instructions: signed
+                        ? "Live classes on BackToSchool.help. classes_list / class_get to see what is on; class_teach puts a broadcast (a nixamp station link, a Pairux room, an https video) on the air as a class in one call; classes_check finds your live classes whose broadcast stopped, and class_end / class_delete clear them. Only broadcast what you have the right to."
+                        : "Live classes on BackToSchool.help: classes_list and class_get. To teach, use /mcp with a nixamp token as the bearer.",
+                } });
+        }
+        else if (name === "ping") {
+            answers.push({ jsonrpc: "2.0", id, result: {} });
+        }
+        else if (name === "tools/list") {
+            answers.push({ jsonrpc: "2.0", id, result: { tools } });
+        }
+        else if (name === "tools/call" && allowed(String(message.params?.["name"] ?? ""))) {
+            const result = await callSchoolTool(String(message.params["name"]), (message.params?.["arguments"] ?? {}), {
+                site, token: ctx.token || null, ...(ctx.fetcher ? { fetcher: ctx.fetcher } : {}),
+            });
+            answers.push({ jsonrpc: "2.0", id, result });
+        }
+        else if (name === "tools/call") {
+            answers.push({ jsonrpc: "2.0", id, error: { code: -32001, message: "only classes_list and class_get are public; for the rest use /mcp with a nixamp token as the bearer (`nixamp token create`), or OAuth" } });
+        }
+        else {
+            answers.push({ jsonrpc: "2.0", id, error: { code: -32601, message: `no method ${name}` } });
+        }
+    }
+    if (answers.length === 0) {
+        response.writeHead(202, CORS);
+        response.end();
+        return true;
+    }
+    response.writeHead(200, { ...CORS, "content-type": "application/json; charset=utf-8" });
+    response.end(JSON.stringify(Array.isArray(parsed) ? answers : answers[0]));
+    return true;
+}

package/dist/school-mcp.d.ts

@@ -0,0 +1,180 @@
+/**
+ * backtoschool.help classes as MCP tools: what `nixamp school` does, for an agent.
+ *
+ * Reading what is on needs nobody; making, starting, ending and deleting a
+ * class needs the token the rest of nixamp uses, because a class is a live
+ * event on the same accounts. `class_teach` is the one-call path from a
+ * station link (station_list / station_create) to a class on the air.
+ */
+import { type SchoolOptions } from "./school-client.ts";
+export declare const SCHOOL_PUBLIC_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                enum: string[];
+            };
+            mine: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+            };
+            slug?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status?: undefined;
+            mine?: undefined;
+            limit?: undefined;
+            slug: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+})[];
+export declare const SCHOOL_TOOLS: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status: {
+                type: string;
+                enum: string[];
+            };
+            mine: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+            };
+            slug?: undefined;
+        };
+        required?: undefined;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            status?: undefined;
+            mine?: undefined;
+            limit?: undefined;
+            slug: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                readonly type: "string";
+            };
+            description: {
+                readonly type: "string";
+            };
+            topic: {
+                readonly type: "string";
+            };
+            visibility: {
+                readonly type: "string";
+                readonly enum: readonly ["public", "unlisted", "private"];
+            };
+            startsAt: {
+                readonly type: "string";
+                readonly description: "ISO 8601; leave out to start now (class_teach) or keep it a draft (class_create).";
+            };
+            chatEnabled: {
+                readonly type: "boolean";
+            };
+            handRaiseEnabled: {
+                readonly type: "boolean";
+            };
+            broadcastUrl: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            title: {
+                readonly type: "string";
+            };
+            description: {
+                readonly type: "string";
+            };
+            topic: {
+                readonly type: "string";
+            };
+            visibility: {
+                readonly type: "string";
+                readonly enum: readonly ["public", "unlisted", "private"];
+            };
+            startsAt: {
+                readonly type: "string";
+                readonly description: "ISO 8601; leave out to start now (class_teach) or keep it a draft (class_create).";
+            };
+            chatEnabled: {
+                readonly type: "boolean";
+            };
+            handRaiseEnabled: {
+                readonly type: "boolean";
+            };
+            slug: {
+                type: "string";
+                description: string;
+            };
+            broadcastUrl: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        required?: undefined;
+        type: string;
+        properties: {};
+    };
+})[];
+export declare function isSchoolTool(name: string): boolean;
+export declare function isSchoolPublicTool(name: string): boolean;
+type Result = {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: boolean;
+};
+export declare function callSchoolTool(name: string, args: Record<string, unknown>, options?: SchoolOptions): Promise<Result>;
+export {};