@nooticr/mcp 1.26.19

package/dist/shared/spend.js

@@ -0,0 +1,158 @@
+/** Mirrors `mcp_tool_cost_for` in crates/server/src/mcp_tools.rs. */
+export const SEARCH_PLATFORMS = [
+    "youtube",
+    "tiktok",
+    "instagram",
+    "douyin",
+    "xiaohongshu",
+    "twitter",
+    "bilibili",
+    "reddit",
+    "weibo",
+];
+/** Two per network, except the one that costs an order of magnitude more upstream. */
+export const CREDITS_PER_NETWORK = 2;
+export const XIAOHONGSHU_CREDITS = 5;
+/** Per creator checked, so the price is the length of the watchlist. */
+export const CREDITS_PER_CREATOR = 2;
+/**
+ * The hard ceilings `search_spoken_mentions` cannot cross, whatever it is
+ * asked for.
+ *
+ * Every other fan-out in this file prices something whose size is already
+ * known once a cheap first call returns — the watchlist length, the post
+ * count of a feed already fetched. A transcript search cannot do that: there
+ * is no way to know how many of a niche's candidates actually say the term
+ * without transcribing them, so the candidate count can never be the number
+ * that sets the price. Left uncapped, a wide niche sweep could spend a hundred
+ * credits transcribing to find three hits. These are the caps that make that
+ * impossible regardless of what `maxTranscripts` or the handle list ask for —
+ * clamp server-side, never trust the argument alone.
+ */
+export const MAX_SPOKEN_TRANSCRIPTS = 20;
+/** get_user_posts calls a spoken-mention search will make, across explicit handles and the watchlist combined. */
+export const MAX_SPOKEN_HANDLE_CALLS = 8;
+/**
+ * What each backend call costs, so a tool that fans out can price itself.
+ *
+ * The job tools in jobs.ts are compositions: `answer_my_audience` is one
+ * `get_user_posts` plus a `get_post_comments` per post it opens, and nothing
+ * else. Billing is therefore the sum of what it actually called, which is only
+ * knowable if the per-call prices are written down somewhere. Mirrors
+ * `mcp_tool_cost_for` in crates/server/src/mcp_tools.rs, same as the constants
+ * above — a call missing from here prices as zero, which would understate a
+ * confirmation rather than overstate it, so add to it when a tool grows a
+ * new fetch.
+ */
+export const BACKEND_CALL_CREDITS = {
+    get_social_media: 1,
+    get_post_transcript: 1,
+    get_user_posts: 2,
+    get_post_comments: 2,
+    discover_social_posts: 2,
+    search_creators: 2,
+    get_similar_creators: 2,
+    discover_sounds: 2,
+    discover_hashtags: 2,
+    get_post_frames: 2,
+};
+/** What a run of backend calls costs, named one per call actually made. */
+export function costOf(calls) {
+    return calls.reduce((total, name) => total + (BACKEND_CALL_CREDITS[name] ?? 0), 0);
+}
+/**
+ * What a `search_mentions` call will cost.
+ *
+ * Omitting `platforms` means every network — which is the expensive default,
+ * and the reason this function exists.
+ */
+export function searchMentionsCost(platforms) {
+    const chosen = platforms && platforms.length > 0
+        ? platforms
+            .map((p) => String(p).toLowerCase())
+            .filter((p) => SEARCH_PLATFORMS.includes(p))
+        : [...SEARCH_PLATFORMS];
+    if (chosen.length === 0)
+        return CREDITS_PER_NETWORK;
+    return chosen.reduce((total, p) => total + (p === "xiaohongshu" ? XIAOHONGSHU_CREDITS : CREDITS_PER_NETWORK), 0);
+}
+/**
+ * Above this, ask. Below it, the number is small enough that a prompt costs
+ * the user more attention than the credits are worth.
+ *
+ * Six is deliberate: a three-network sweep (6) passes silently, a four-network
+ * one (8) does not, and the all-networks default (21) never does.
+ */
+export const CONFIRM_ABOVE_CREDITS = 6;
+/** A client that never declared elicitation must not be sent one. */
+function canAsk(server) {
+    const caps = server.getClientCapabilities();
+    return Boolean(caps && "elicitation" in caps && caps.elicitation);
+}
+/**
+ * Ask before spending. Returns whether to go ahead.
+ *
+ * Anything unexpected — a client that declared elicitation and then threw, a
+ * transport that dropped — proceeds. The failure mode of a broken confirmation
+ * should be the behaviour we had before it existed, not a tool that stopped
+ * working.
+ */
+export async function confirmSpend(server, opts) {
+    if (!opts.always && opts.credits <= CONFIRM_ABOVE_CREDITS)
+        return { proceed: true };
+    if (!canAsk(server))
+        return { proceed: true };
+    const cost = opts.prompt?.cost ?? `This costs ${opts.credits} nooticr credits.`;
+    const lines = [`${opts.summary} ${cost}`];
+    if (opts.cheaper)
+        lines.push(opts.cheaper);
+    let result;
+    try {
+        result = (await server.elicitInput({
+            mode: "form",
+            message: lines.join(" "),
+            requestedSchema: {
+                type: "object",
+                properties: {
+                    proceed: {
+                        type: "boolean",
+                        title: opts.prompt?.title ?? `Spend ${opts.credits} credits`,
+                        description: opts.prompt?.action ?? "Run the search now.",
+                    },
+                },
+                required: ["proceed"],
+            },
+        }));
+        // "accept" with proceed:false is a user who read the form and said no; it
+        // is not the same as dismissing the dialog, but it is still a no.
+        const accepted = result.action === "accept" &&
+            result.content?.proceed !== false;
+        if (accepted)
+            return { proceed: true, approved: true };
+        return { proceed: false, declined: result.action === "decline" ? "decline" : "cancel" };
+    }
+    catch {
+        return { proceed: true };
+    }
+}
+/**
+ * What the caller returns when the user said no. Not an error — a choice.
+ *
+ * `cheaper` is the way out. It defaults to the platforms argument because
+ * `search_mentions` was the first caller and that is its lever, but a tool
+ * that fans out over posts rather than networks has a different one, and
+ * telling a user to narrow a "platforms" argument the tool does not have is
+ * worse than saying nothing.
+ */
+export function declinedResult(credits, what, cheaper) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `Cancelled — no credits were spent. ${what} would have cost ${credits} credits. ` +
+                    (cheaper ?? `Narrow it with the "platforms" argument to spend less.`),
+            },
+        ],
+        structuredContent: { cancelled: true, wouldHaveCost: credits },
+    };
+}

package/dist/shared/tasks.js

@@ -0,0 +1,88 @@
+/**
+ * Long calls, made honest.
+ *
+ * Every tool here declared `taskSupport: "forbidden"` — the SDK default, never
+ * chosen — including the ones that watch a video. POLL_TIMEOUT_MS is five
+ * minutes, so analyze_post could hold a synchronous tools/call open for that
+ * long and a host had no way to put it in the background. Measured against the
+ * live server, discover_social_posts takes 10.3s and compare_posts 10.4s; the
+ * multimodal tools wrapped here are the slow ones above them.
+ *
+ * The three tools that run longest now accept a task. What they do is
+ * unchanged: the existing handler is moved onto a background run and its
+ * result stored, so a client that asks for a task gets a task id it can poll,
+ * and a client that does not is auto-polled by the SDK and sees exactly the
+ * same result it saw before. That compatibility is the reason for `optional`
+ * rather than `required`.
+ *
+ * The store is in memory, per session. A task does not survive a restart —
+ * neither did the synchronous call it replaces, so nothing regresses, and the
+ * result outliving the request by fifteen minutes is new ground either way.
+ * When these need to survive a deploy, the store is the piece to replace: the
+ * worker already has a SQLite Durable Object under the session.
+ *
+ * The task APIs are experimental in SDK 1.30 and may change under us. They are
+ * contained here for that reason — one file to fix rather than three handlers.
+ */
+import { InMemoryTaskStore } from "@modelcontextprotocol/sdk/experimental/tasks/stores/in-memory.js";
+/** How long a finished result stays fetchable. */
+export const TASK_TTL_MS = 900_000;
+/**
+ * How often a client is told to poll — and, because the SDK auto-polls at this
+ * interval for a client that asked for no task, a floor on how fast those
+ * calls can now return. Measured: a plain call that would have answered
+ * instantly takes one interval. The SDK's default is 5s; these tools import
+ * media and run multimodal AI over it, so 2s is a rounding error against the
+ * work and cheap enough to poll over HTTP for the five minutes it may run.
+ * Only the three slowest tools are wrapped, so nothing quick pays this.
+ */
+export const TASK_POLL_MS = 2_000;
+/**
+ * The default store: in memory, which is correct for stdio because the process
+ * *is* the session — when it exits there is nothing left to poll for.
+ *
+ * It is wrong for the Worker, where the Durable Object holding the server is
+ * restarted by eviction, hibernation and every deploy, taking every in-flight
+ * task with it. That transport passes its own durable store; see
+ * `cloudflare/src/taskStore.ts`.
+ */
+export function createTaskStore() {
+    return new InMemoryTaskStore();
+}
+/**
+ * Registers a tool whose work is slow enough to deserve a task, keeping the
+ * handler exactly as it was written for the synchronous path.
+ */
+export function registerSlowTool(server, name, config, run) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tasks = server.experimental.tasks;
+    tasks.registerToolTask(name, { ...config, execution: { taskSupport: "optional" } }, {
+        createTask: async (args, extra) => {
+            const task = await extra.taskStore.createTask({ ttl: TASK_TTL_MS, pollInterval: TASK_POLL_MS });
+            // Deliberately not awaited: createTask must return the id now, and the
+            // work carries on past the end of this request. Nothing in these
+            // handlers reads extra.signal, and makeClient takes only plain values
+            // off extra (authInfo, requestId, arguments), so none of it goes stale
+            // when the request that started it completes.
+            void (async () => {
+                try {
+                    const result = await run(args, extra);
+                    await extra.taskStore.storeTaskResult(task.taskId, result?.isError ? "failed" : "completed", result);
+                }
+                catch (err) {
+                    // A throw here has nowhere to go — the request is long gone — so
+                    // it has to land in the task or the client polls a task that never
+                    // finishes.
+                    const message = err instanceof Error ? err.message : String(err);
+                    await extra.taskStore.storeTaskResult(task.taskId, "failed", {
+                        content: [{ type: "text", text: `${name} failed: ${message}` }],
+                        isError: true,
+                    });
+                }
+            })();
+            return { task };
+        },
+        getTask: async (_args, extra) => extra.taskStore.getTask(extra.taskId),
+        getTaskResult: async (_args, extra) => extra.taskStore.getTaskResult(extra.taskId),
+    });
+}