@sendora/mcp 1.3.3 → 1.4.0

package/dist/grant.js

@@ -0,0 +1,95 @@
+import { Sendora, SendoraAccount } from '@sendora/sdk';
+import { z } from 'zod';
+/*
+ * A connected app's connection (docs/design/oauth.md §6). The hosted process
+ * never passes the app's access token on: it trades the token at the API's
+ * exchange for a short credential of its own. Every call then presents that
+ * credential with the process's secret in `Sendora-Internal`, and a server's
+ * call names its server in `Sendora-Server`. The SDK takes headers only
+ * through its `fetch` (§6.4).
+ */
+const exchangedSchema = z.object({
+    grantId: z.string(),
+    servers: z.array(z.object({
+        serverId: z.string(),
+        name: z.string(),
+        mode: z.enum(['test', 'live']),
+        createdAt: z.string(),
+    })),
+    account: z.boolean(),
+    changes: z.boolean(),
+    credential: z.string(),
+});
+/** An access token the exchange refuses: unknown, expired, or its grant ended. */
+export class TokenRefused extends Error {
+    name = 'TokenRefused';
+}
+/** The exchange could not be reached, or failed on its side; the client may try again. */
+export class ExchangeUnavailable extends Error {
+    name = 'ExchangeUnavailable';
+}
+/** Trades an access token for what its grant reaches and a credential. */
+export async function exchange(accessToken, options) {
+    let response;
+    try {
+        response = await (options.fetch ?? fetch)(`${options.baseUrl}/internal/oauth/exchange`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', 'sendora-internal': options.internalToken },
+            body: JSON.stringify({ accessToken }),
+        });
+    }
+    catch (error) {
+        throw new ExchangeUnavailable('the exchange is out of reach', { cause: error });
+    }
+    if (response.status === 401) {
+        throw new TokenRefused('the exchange refuses the access token');
+    }
+    if (response.status >= 500) {
+        throw new ExchangeUnavailable(`the exchange answered ${String(response.status)}`);
+    }
+    if (response.status !== 200) {
+        throw new Error(`the exchange answered ${String(response.status)}`);
+    }
+    return exchangedSchema.parse(await response.json());
+}
+/** A fetch that sets these headers on every request it sends. */
+function withHeaders(base, headers) {
+    return (input, init) => {
+        const merged = new Headers(init?.headers);
+        for (const [name, value] of Object.entries(headers)) {
+            merged.set(name, value);
+        }
+        return base(input, { ...init, headers: merged });
+    };
+}
+/** The connection an exchange's answer opens: a client of its own for each server, and the account's, read only. */
+export function grantConnection(exchanged, options) {
+    const base = options.fetch ?? fetch;
+    const internal = { 'sendora-internal': options.internalToken };
+    const client = (headers) => ({
+        token: exchanged.credential,
+        baseUrl: options.baseUrl,
+        fetch: withHeaders(base, headers),
+    });
+    return {
+        kind: 'grant',
+        grantId: exchanged.grantId,
+        servers: exchanged.servers.map(({ createdAt, ...server }) => ({
+            kind: server.mode,
+            writes: exchanged.changes,
+            sendora: new Sendora(client({ ...internal, 'sendora-server': server.serverId })),
+            ownKey: () => false,
+            server,
+            createdAt,
+        })),
+        account: exchanged.account
+            ? {
+                kind: 'account',
+                writes: false,
+                account: new SendoraAccount(client(internal)),
+                confirmed: true,
+            }
+            : undefined,
+        changes: exchanged.changes,
+    };
+}

package/dist/handler.js

@@ -1,17 +1,20 @@
 import { createHash } from 'node:crypto';
 import { createMcpHandler, hostHeaderValidationResponse, originValidationResponse, } from '@modelcontextprotocol/server';
 import { connect, KEYS_PAGE, KeyRefused, verifiedOf, writesFrom, } from './connection.js';
+import { exchange, ExchangeUnavailable, grantConnection, TokenRefused, } from './grant.js';
 import { buildServer } from './server.js';
 const REMEMBERED_MS = 60_000;
 const REMEMBERED_KEYS = 10_000;
 /** The largest request the hosted server takes, 8 MB (docs/design/mcp.md §2.3); the MCP SDK's own default is 4. */
 export const MAX_BODY_BYTES = 8 * 1024 * 1024;
 /**
- * What the API confirmed of each key, by the key's SHA-256, for a minute and
- * for at most 10,000 keys, the oldest forgotten first. The key itself is
- * never kept: a request hands it to the SDK and drops it (docs/design/mcp.md
- * §2.3). A revoked key may list tools for that minute; every call it makes
- * is refused by the API meanwhile.
+ * What the API confirmed of each key, or what the exchange answered for each
+ * connected app's token, by its SHA-256, for a minute and for at most 10,000,
+ * the oldest forgotten first. A key or an app's token is never kept: a
+ * request hands it on and drops it (docs/design/mcp.md §2.3); the exchange's
+ * own credential is kept for that minute. A revoked key or an ended
+ * connection may list tools for that minute; every call it makes is refused
+ * by the API meanwhile (docs/design/oauth.md §6.1).
  */
 export class KeyCache {
     #entries = new Map();
@@ -52,12 +55,71 @@ function hashOf(key) {
 export function bearerOf(request) {
     return /^Bearer\s+(\S+)$/i.exec(request.headers.get('authorization') ?? '')?.[1];
 }
-function unauthorized(request, reason) {
+const KEY_CHALLENGE = 'Bearer realm="sendora"';
+const METADATA_PATH = '/.well-known/oauth-protected-resource';
+/** RFC 9728's address for a resource's metadata: the well-known path, then the resource's own. */
+function metadataPathOf(resource) {
+    return `${METADATA_PATH}${new URL(resource).pathname}`;
+}
+/** The challenge that sends an OAuth client to the resource's metadata (docs/design/oauth.md §2.2). */
+function oauthChallenge(oauth, error) {
+    const metadata = `${new URL(oauth.resource).origin}${metadataPathOf(oauth.resource)}`;
+    const refused = error === undefined ? '' : `error="${error}", `;
+    return `Bearer ${refused}resource_metadata="${metadata}", scope="mcp"`;
+}
+function unauthorized(request, reason, challenge) {
     const docs = new URL('/docs', request.url).href;
     return Response.json({
         error: 'unauthorized',
         message: `${reason} This address takes a Sendora key as a bearer token, Authorization: Bearer <key>; ${docs} serves the documentation without one.`,
-    }, { status: 401, headers: { 'www-authenticate': 'Bearer realm="sendora"' } });
+    }, { status: 401, headers: { 'www-authenticate': challenge } });
+}
+function invalidToken(oauth) {
+    return Response.json({
+        error: 'invalid_token',
+        message: 'The access token is unknown, expired or ended. Renew it, or connect again.',
+    }, { status: 401, headers: { 'www-authenticate': oauthChallenge(oauth, 'invalid_token') } });
+}
+function unavailable() {
+    return Response.json({ error: 'unavailable', message: "Sendora's API cannot be reached. Try again shortly." }, { status: 503 });
+}
+/** RFC 9728 metadata, which any origin may read. */
+function resourceMetadata(request, oauth) {
+    const cors = { 'access-control-allow-origin': '*' };
+    if (request.method === 'OPTIONS') {
+        return new Response(null, {
+            status: 204,
+            headers: {
+                ...cors,
+                'access-control-allow-methods': 'GET, OPTIONS',
+                'access-control-allow-headers': 'mcp-protocol-version',
+                'access-control-max-age': '86400',
+            },
+        });
+    }
+    if (request.method !== 'GET') {
+        return new Response(null, { status: 405, headers: { ...cors, allow: 'GET, OPTIONS' } });
+    }
+    return Response.json({
+        resource: oauth.resource,
+        authorization_servers: [oauth.issuer],
+        scopes_supported: ['mcp'],
+        bearer_methods_supported: ['header'],
+        resource_name: 'Sendora',
+        resource_documentation: 'https://sendora.se/docs/mcp',
+    }, { headers: { ...cors, 'cache-control': 'public, max-age=3600' } });
+}
+function appsOf({ oauth, api }) {
+    if (oauth === undefined) {
+        return undefined;
+    }
+    if (api?.baseUrl === undefined) {
+        throw new Error('a connected app is exchanged at the API on its own network: set api.baseUrl');
+    }
+    return {
+        oauth,
+        exchanging: { baseUrl: api.baseUrl, internalToken: oauth.internalToken, fetch: api.fetch },
+    };
 }
 /** The connection `fetch` hands the keyed server's factory in `authInfo`. */
 export function connectionIn(authInfo) {
@@ -73,7 +135,9 @@ export function connectionIn(authInfo) {
  * only for the host names it is given, and refuses a request whose `Origin`
  * is any other site's: the specification's guard against DNS rebinding.
  * `/docs` is the keyless server; `/mcp` takes a key, and without one answers
- * 401, so that OAuth can later begin there without breaking anyone (§2.3).
+ * 401 (§2.3). With `oauth`, `/mcp` also takes a connected app's token, and
+ * the 401 points to the resource's metadata, which any origin may read
+ * (docs/design/oauth.md §2.2).
  */
 export function httpHandler(docs, options) {
     const served = {
@@ -83,48 +147,85 @@ export function httpHandler(docs, options) {
     const keyless = createMcpHandler(() => buildServer(docs, { kind: 'none' }), served);
     const keyed = createMcpHandler(({ authInfo }) => buildServer(docs, connectionIn(authInfo)), served);
     const cache = options.cache ?? new KeyCache();
+    const apps = appsOf(options);
+    async function keyConnection(request, key, hash) {
+        const remembered = cache.get(hash);
+        try {
+            const connection = await connect(key, {
+                writes: writesFrom(request.headers.get('sendora-allow-writes') ?? undefined),
+                baseUrl: options.api?.baseUrl,
+                fetch: options.api?.fetch,
+                verified: remembered,
+            });
+            const verified = verifiedOf(connection);
+            if (remembered === undefined && verified !== undefined) {
+                cache.set(hash, verified);
+            }
+            return connection;
+        }
+        catch (error) {
+            if (error instanceof KeyRefused) {
+                return unauthorized(request, error.message, KEY_CHALLENGE);
+            }
+            throw error;
+        }
+    }
+    async function appConnection(token, hash, { oauth, exchanging }) {
+        const remembered = cache.get(hash);
+        if (remembered?.kind === 'grant') {
+            return grantConnection(remembered.exchanged, exchanging);
+        }
+        try {
+            const exchanged = await exchange(token, exchanging);
+            cache.set(hash, { kind: 'grant', exchanged });
+            return grantConnection(exchanged, exchanging);
+        }
+        catch (error) {
+            if (error instanceof TokenRefused) {
+                return invalidToken(oauth);
+            }
+            if (error instanceof ExchangeUnavailable) {
+                return unavailable();
+            }
+            throw error;
+        }
+    }
     return {
         fetch: async (request) => {
-            const refused = hostHeaderValidationResponse(request, options.hosts) ??
-                originValidationResponse(request, options.hosts);
-            if (refused !== undefined) {
-                return refused;
+            const wrongHost = hostHeaderValidationResponse(request, options.hosts);
+            if (wrongHost !== undefined) {
+                return wrongHost;
             }
             const path = new URL(request.url).pathname;
+            if (apps !== undefined &&
+                (path === METADATA_PATH || path === metadataPathOf(apps.oauth.resource))) {
+                return resourceMetadata(request, apps.oauth);
+            }
+            const wrongOrigin = originValidationResponse(request, options.hosts);
+            if (wrongOrigin !== undefined) {
+                return wrongOrigin;
+            }
             if (path === '/docs') {
                 return keyless.fetch(request);
             }
             if (path !== '/mcp') {
                 return new Response('Not found', { status: 404 });
             }
-            const key = bearerOf(request);
-            if (key === undefined) {
-                return unauthorized(request, `No key was given. Keys are made in the dashboard, ${KEYS_PAGE}.`);
-            }
-            const hash = hashOf(key);
-            const remembered = cache.get(hash);
-            let connection;
-            try {
-                connection = await connect(key, {
-                    writes: writesFrom(request.headers.get('sendora-allow-writes') ?? undefined),
-                    baseUrl: options.api?.baseUrl,
-                    fetch: options.api?.fetch,
-                    verified: remembered,
-                });
+            const token = bearerOf(request);
+            if (token === undefined) {
+                return unauthorized(request, `No key was given. Keys are made in the dashboard, ${KEYS_PAGE}.`, apps === undefined ? KEY_CHALLENGE : oauthChallenge(apps.oauth));
             }
-            catch (error) {
-                if (error instanceof KeyRefused) {
-                    return unauthorized(request, error.message);
-                }
-                throw error;
-            }
-            const verified = verifiedOf(connection);
-            if (remembered === undefined && verified !== undefined) {
-                cache.set(hash, verified);
+            const hash = hashOf(token);
+            const opened = apps !== undefined && token.startsWith('oat_')
+                ? await appConnection(token, hash, apps)
+                : await keyConnection(request, token, hash);
+            if (opened instanceof Response) {
+                return opened;
             }
+            const connection = opened;
             options.onConnection?.(request, connection);
             return keyed.fetch(request, {
-                authInfo: { token: hash, clientId: 'sendora-key', scopes: [], extra: { connection } },
+                authInfo: { token: hash, clientId: 'sendora', scopes: [], extra: { connection } },
             });
         },
     };

package/dist/instructions.js

@@ -1,16 +1,25 @@
-import { KEYS_PAGE } from './connection.js';
+import { KEYS_PAGE, } from './connection.js';
 import { INDEX_URI } from './docs.js';
-import { LIVE_NOTE, SIMULATOR_NOTE, WRITES_OFF_NOTE } from './tools/server.js';
+import { grantNote, LIVE_NOTE, SIMULATOR_NOTE, WRITES_OFF_NOTE } from './tools/server.js';
 const ABOUT = "Sendora is a transactional email service: an HTTP API, SMTP submission, SDKs for TypeScript (@sendora/sdk) and Python (sendora), signed webhooks and a message log with every delivery event. This server carries Sendora's documentation, and with a key, tools for that key's server or account.";
 const DOCS = `Use the SDK for the project's language: @sendora/sdk for TypeScript or JavaScript, sendora for Python, the HTTP API otherwise. Before writing code, find the answer with search_docs and read the document with read_doc; ${INDEX_URI} lists them all, and sendora://sdk/skill and sendora://sdk/python/skill hold the rules an agent must keep with each SDK.`;
 const KEYS = 'Never print or repeat a Sendora key, and never write one into a file under version control; keys belong in the environment.';
 const LIVE_DASHBOARD = `A person makes and revokes this server's keys, and makes and deletes its webhooks, in the dashboard, ${KEYS_PAGE}, with changes on or off, since a new key or signing secret must not reach this conversation.`;
 const ACCOUNT_DASHBOARD = `A server and a key are made in the dashboard, ${KEYS_PAGE}, since a new key is a secret this conversation must not see; a live server is deleted there too.`;
+const GRANT_LIMITS = `Through a connected app, keys, webhooks and what cannot be undone happen on test servers alone, and the account is read only; a person does the rest in the dashboard, ${KEYS_PAGE}. The person sees and ends this connection under Account › Connected apps (Konto › Anslutna appar).`;
 function serverName(connection) {
     return connection.server === undefined
         ? `a ${connection.kind} server the API could not name when this connection opened`
         : `the ${connection.kind} server "${connection.server.name}"`;
 }
+function grantChanges(grant) {
+    if (!grant.servers.some(({ kind }) => kind === 'live')) {
+        return 'Nothing sent from a test server is delivered.';
+    }
+    return grant.changes
+        ? 'Mail sent from a live server reaches real people: confirm with the user before anything does.'
+        : 'The person who approved this connection allowed no changes on live servers, so it only reads them.';
+}
 /** What the server tells a client's model before any call (docs/design/mcp.md §3.5), for this connection. */
 export function instructionsFor(connection) {
     switch (connection.kind) {
@@ -41,5 +50,12 @@ export function instructionsFor(connection) {
                 DOCS,
                 KEYS,
             ].join('\n\n');
+        case 'grant':
+            return [
+                ABOUT,
+                `${grantNote(connection)} Call get_server first for each server you act on. ${grantChanges(connection)} ${GRANT_LIMITS}`,
+                DOCS,
+                KEYS,
+            ].join('\n\n');
     }
 }

package/dist/listing.js

@@ -4,6 +4,8 @@
  * the user switches changes on; a secret reaches the model only on a test
  * server; what cannot be undone is a test server's, or the account key's
  * with the switch, the tool itself refusing any server not in test mode.
+ * A connected app's connection lists what a key of each server its grant
+ * reaches would, and the account's reads (docs/design/oauth.md §5.1).
  */
 export function reaches(reach, kind) {
     switch (reach) {
@@ -35,7 +37,28 @@ export function allowed(toolClass, kind, writes) {
 export function listedFor(tool, kind, writes) {
     return reaches(tool.reach, kind) && allowed(tool.class, kind, writes);
 }
+/** What a grant reaches, each part connected as a key of it would be. */
+function partsOf(grant) {
+    return grant.account === undefined ? grant.servers : [...grant.servers, grant.account];
+}
 /** Whether the connection lists the tool; a tool it does not list is not registered at all. */
 export function listed(tool, connection) {
+    if (connection.kind === 'grant') {
+        return partsOf(connection).some((part) => listed(tool, part));
+    }
     return listedFor(tool, connection.kind, connection.kind !== 'none' && connection.writes);
 }
+/** Where a server tool's calls go: a key's own server, or each of a grant's servers that lists it. */
+export function targetsFor(tool, connection) {
+    if (connection.kind === 'test' || connection.kind === 'live') {
+        return { kind: 'key', server: connection };
+    }
+    if (connection.kind === 'grant') {
+        return {
+            kind: 'grant',
+            servers: connection.servers.filter((server) => listed(tool, server)),
+            required: connection.servers.length > 1,
+        };
+    }
+    return undefined;
+}

package/dist/server.js

@@ -1,7 +1,7 @@
 import { McpServer } from '@modelcontextprotocol/server';
 import { registerDocuments } from './documents.js';
 import { instructionsFor } from './instructions.js';
-import { listed } from './listing.js';
+import { listed, targetsFor } from './listing.js';
 import { registerPrompts } from './prompts.js';
 import { toolTable } from './tool-table.js';
 import { MCP_VERSION } from './version.js';
@@ -35,7 +35,7 @@ export function buildServer(docs, connection) {
     });
     for (const tool of toolTable) {
         if (listed(tool, connection)) {
-            tool.register(server, { docs, connection });
+            tool.register(server, { docs, connection, targets: targetsFor(tool, connection) });
         }
     }
     registerDocuments(server, docs);

package/dist/target.js

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+/** The modes of the servers a tool acts on here, for wording that differs between a test server and a live one. */
+export function modesOf(targets) {
+    if (targets === undefined) {
+        return [];
+    }
+    const kinds = targets.kind === 'key' ? [targets.server.kind] : targets.servers.map(({ kind }) => kind);
+    return ['test', 'live'].filter((mode) => kinds.includes(mode));
+}
+function serverArgument(targets) {
+    const choices = targets.servers
+        .map(({ kind, server }) => `${server.serverId} for the ${kind} server "${server.name}"`)
+        .join('; ');
+    const ids = z.enum(targets.servers.map(({ server }) => server.serverId));
+    return targets.required
+        ? ids.describe(`The server this call acts on, by its id: ${choices}. This connection reaches more than one server, so every call names one.`)
+        : ids
+            .optional()
+            .describe(`The server this call acts on, by its id: ${choices}. It may be left out, since this connection reaches no other.`);
+}
+function targetOf(targets, serverId) {
+    const target = serverId === undefined
+        ? targets.servers[0]
+        : targets.servers.find(({ server }) => server.serverId === serverId);
+    if (target === undefined) {
+        throw new Error('the input schema let through a server the tool does not act on');
+    }
+    return target;
+}
+/**
+ * Registers a server tool. Its `call` gets the server to act on: the key's
+ * own, or on a connected app's connection the one the call names in `server`.
+ */
+export function registerServerTool(mcp, targets, name, config, call) {
+    if (targets === undefined) {
+        throw new Error('a server tool was registered on a connection without a server');
+    }
+    // Each tool's own call is typed by its schema; registered, both are any object's.
+    const registered = config;
+    const typed = (args) => args;
+    switch (targets.kind) {
+        case 'key':
+            return mcp.registerTool(name, registered, (args) => call(typed(args), targets.server));
+        case 'grant': {
+            const inputSchema = registered.inputSchema.safeExtend({ server: serverArgument(targets) });
+            return mcp.registerTool(name, { ...registered, inputSchema }, ({ server, ...args }) => call(typed(args), targetOf(targets, server)));
+        }
+    }
+}

package/dist/tools/broadcasts.js

@@ -2,7 +2,8 @@ import { z } from 'zod';
 import { toolError } from '../errors.js';
 import { READING } from '../tool.js';
 import { broadcastInput } from './broadcast-input.js';
-import { serverConnectionOf, SIMULATOR_NOTE } from './server.js';
+import { registerServerTool } from '../target.js';
+import { SIMULATOR_NOTE } from './server.js';
 export const acceptedBroadcastOutput = z.object({
     broadcastId: z.string().describe('What get_broadcast, cancel_broadcast and the log refer to.'),
     status: z.literal('accepted').describe('Accepted; its messages leave as the stream drains.'),
@@ -67,7 +68,7 @@ export const sendBroadcastTool = {
     class: 'irreversible',
     reach: 'server',
     operations: ['POST /v1/broadcasts'],
-    register: (server, { connection }) => server.registerTool('send_broadcast', {
+    register: (server, { connection, targets }) => registerServerTool(server, targets, 'send_broadcast', {
         title: 'Send a test broadcast',
         description: `Sends a broadcast from this test server, to try one before code sends the real list with an SDK: the content once and one message per entry, at most 100, on a broadcast stream (create_stream makes one). Put {{ unsubscribe_url }} in the text or HTML where each recipient's unsubscribe link goes, and {{ key }} for each entry's substitutions. Addresses on the stream's suppression list are dropped and counted. A broadcast sent cannot be taken back; cancel_broadcast stops what has not left. Follow it with get_broadcast. ${SIMULATOR_NOTE}`,
         inputSchema: broadcastInput,
@@ -78,16 +79,16 @@ export const sendBroadcastTool = {
             idempotentHint: false,
             openWorldHint: false,
         },
-    }, async (input) => {
+    }, async (input, { sendora }) => {
         try {
-            const accepted = await serverConnectionOf(connection).sendora.broadcasts.send(broadcastRequestOf(input));
+            const accepted = await sendora.broadcasts.send(broadcastRequestOf(input));
             return {
                 content: [{ type: 'text', text: JSON.stringify(accepted) }],
                 structuredContent: accepted,
             };
         }
         catch (error) {
-            return toolError(error);
+            return toolError(error, connection);
         }
     }),
 };
@@ -101,22 +102,22 @@ export const getBroadcastTool = {
     class: 'read',
     reach: 'server',
     operations: ['GET /v1/broadcasts/{id}'],
-    register: (server, { connection }) => server.registerTool('get_broadcast', {
+    register: (server, { connection, targets }) => registerServerTool(server, targets, 'get_broadcast', {
         title: 'Read a broadcast',
         description: 'Reads a broadcast of this server and how far it has come: released and failed move as its messages leave, and status is completed once none is left. Each of its messages is in the log; search_messages with its broadcastId finds them.',
         inputSchema: broadcastIdInput,
         outputSchema: broadcastOutput,
         annotations: READING,
-    }, async ({ broadcastId }) => {
+    }, async ({ broadcastId }, { sendora }) => {
         try {
-            const broadcast = await serverConnectionOf(connection).sendora.broadcasts.get(broadcastId);
+            const broadcast = await sendora.broadcasts.get(broadcastId);
             return {
                 content: [{ type: 'text', text: JSON.stringify(broadcast) }],
                 structuredContent: broadcast,
             };
         }
         catch (error) {
-            return toolError(error);
+            return toolError(error, connection);
         }
     }),
 };
@@ -127,7 +128,7 @@ export const cancelBroadcastTool = {
     class: 'irreversible',
     reach: 'server',
     operations: ['POST /v1/broadcasts/{id}/cancel'],
-    register: (server, { connection }) => server.registerTool('cancel_broadcast', {
+    register: (server, { connection, targets }) => registerServerTool(server, targets, 'cancel_broadcast', {
         title: 'Cancel a broadcast',
         description: 'Cancels the messages of a broadcast of this test server that have not left yet, which then count as failed; those that left stay sent. A cancelled broadcast cannot be resumed.',
         inputSchema: broadcastIdInput,
@@ -138,16 +139,16 @@ export const cancelBroadcastTool = {
             idempotentHint: true,
             openWorldHint: false,
         },
-    }, async ({ broadcastId }) => {
+    }, async ({ broadcastId }, { sendora }) => {
         try {
-            const broadcast = await serverConnectionOf(connection).sendora.broadcasts.cancel(broadcastId);
+            const broadcast = await sendora.broadcasts.cancel(broadcastId);
             return {
                 content: [{ type: 'text', text: JSON.stringify(broadcast) }],
                 structuredContent: broadcast,
             };
         }
         catch (error) {
-            return toolError(error);
+            return toolError(error, connection);
         }
     }),
 };

package/dist/tools/domains.js

@@ -67,7 +67,7 @@ export const listDomainsTool = {
             };
         }
         catch (error) {
-            return toolError(error);
+            return toolError(error, connection);
         }
     }),
 };
@@ -95,7 +95,7 @@ export const checkDomainTool = {
             };
         }
         catch (error) {
-            return toolError(error);
+            return toolError(error, connection);
         }
     }),
 };
@@ -130,7 +130,7 @@ export const addDomainTool = {
             };
         }
         catch (error) {
-            return toolError(error);
+            return toolError(error, connection);
         }
     }),
 };