@trillet-ai/mcp 0.7.3 → 0.8.0

package/dist/index.js

@@ -25,6 +25,7 @@ import { registerFlowSettingTools } from "./tools/flowSettings.js";
 import { registerSecretTools } from "./tools/secrets.js";
 import { registerAccountTools } from "./tools/account.js";
 import { registerTextCallTools } from "./tools/textCalls.js";
+import { registerBrandingTools } from "./tools/branding.js";
 import { runTextCallWorker } from "./textcall/worker.js";
 import { VERSION } from "./version.js";
 async function main() {
@@ -44,6 +45,7 @@ async function main() {
     registerSecretTools(server, client);
     registerCallTools(server, client);
     registerTextCallTools(server, client);
+    registerBrandingTools(server, client);
     registerAccountTools(server, client);
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/registry.js

@@ -1,7 +1,7 @@
 /**
  * Transport-agnostic tool registry.
  *
- * The same 76 tools power three surfaces: the stdio MCP server (Claude Code
+ * The same 83 tools power three surfaces: the stdio MCP server (Claude Code
  * plugin + Desktop .mcpb), a future remote MCP, and the in-dashboard AI
  * assistant (trillet-backend embeds the bundled build of this module and runs
  * the tools inside its own Anthropic loop).
@@ -10,7 +10,7 @@
  * register*Tools() functions, so the tool files stay exactly as written for
  * the MCP SDK — no churn, no drift between surfaces. Handlers close over the
  * TrilletClient passed to buildRegistry(), so embedders build one registry
- * per authenticated session (cheap: 76 object literals).
+ * per authenticated session (cheap: 83 object literals).
  */
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
@@ -27,6 +27,7 @@ import { registerFlowSettingTools } from "./tools/flowSettings.js";
 import { registerSecretTools } from "./tools/secrets.js";
 import { registerAccountTools } from "./tools/account.js";
 import { registerTextCallTools } from "./tools/textCalls.js";
+import { registerBrandingTools } from "./tools/branding.js";
 const REGISTER_FNS = [
     registerAgentTools,
     registerCallFlowTools,
@@ -38,6 +39,7 @@ const REGISTER_FNS = [
     registerSecretTools,
     registerCallTools,
     registerTextCallTools,
+    registerBrandingTools,
     registerAccountTools,
 ];
 /** Collect every tool, with handlers bound to the given client. */

package/dist/tools/branding.js

@@ -0,0 +1,416 @@
+import { z } from "zod";
+import { readFile } from "node:fs/promises";
+import { basename } from "node:path";
+import { ok, guard, workspaceParam } from "../helpers.js";
+/**
+ * Website widget + custom demo page tools.
+ *
+ * Both designs live OUTSIDE draft-synced settings and apply to production the
+ * moment they are saved (the backend ignores x-trillet-write-target on these
+ * routes, exactly like the dashboard designers). Both save routes REPLACE the
+ * whole design and fill missing keys with defaults, so every setter here reads
+ * the stored design first and sends the merged result.
+ */
+const WIDGET_SCRIPT_URL = "https://unpkg.com/@trillet-ai/web-sdk/dist/widget.umd.js";
+const APP_ORIGIN = "https://app.trillet.ai";
+const MAX_IMAGE_BYTES = 2 * 1024 * 1024;
+const hex = z
+    .string()
+    .regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, "hex colour like #1060ff");
+const httpsUrl = z.string().url().refine((u) => u.startsWith("https://"), "must be an https URL");
+function escapeAttr(value) {
+    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+/** Same two lines the dashboard's "Get embed code" produces. */
+function widgetSnippet(agentId, workspaceId) {
+    return [
+        `<script src="${WIDGET_SCRIPT_URL}" async type="text/javascript"></script>`,
+        `<trillet-widget agent-id="${escapeAttr(agentId)}" workspace-id="${escapeAttr(workspaceId)}"></trillet-widget>`,
+    ].join("\n");
+}
+function demoUrl(hash) {
+    return `${APP_ORIGIN}/call-flows/demo/${hash}`;
+}
+function iframeSnippet(hash, title) {
+    return `<iframe src="${demoUrl(hash)}?embed=1" title="${escapeAttr(title)}" allow="microphone; autoplay" style="width:100%;max-width:640px;height:720px;border:0"></iframe>`;
+}
+const DEMO_URL_NOTE = "URLs use app.trillet.ai. A whitelabel (agency) workspace shares the same path on its custom domain: https://<customDomain>/call-flows/demo/<hash>.";
+/** Sniff PNG/JPEG/WebP from the bytes (the backend does the same and rejects anything else). */
+function sniffImage(buf) {
+    if (buf.length < 12)
+        return null;
+    if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47)
+        return { mime: "image/png", ext: "png" };
+    if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff)
+        return { mime: "image/jpeg", ext: "jpg" };
+    const ascii = (a, b) => String.fromCharCode(...buf.slice(a, b));
+    if (ascii(0, 4) === "RIFF" && ascii(8, 12) === "WEBP")
+        return { mime: "image/webp", ext: "webp" };
+    return null;
+}
+async function loadImage(file_path, image_url) {
+    if (file_path) {
+        return { data: new Uint8Array(await readFile(file_path)), name: basename(file_path) };
+    }
+    if (!image_url || !image_url.startsWith("https://")) {
+        throw new Error("Pass file_path (a local PNG/JPG/WebP) or an https image_url.");
+    }
+    const res = await fetch(image_url);
+    if (!res.ok)
+        throw new Error(`Could not download ${image_url}: HTTP ${res.status}`);
+    const data = new Uint8Array(await res.arrayBuffer());
+    return { data, name: basename(new URL(image_url).pathname) || "logo" };
+}
+/** Plain-object deep merge: patch wins, arrays replace, undefined is skipped. */
+function deepMerge(base, patch) {
+    if (patch === undefined)
+        return base;
+    if (patch === null || typeof patch !== "object" || Array.isArray(patch))
+        return patch;
+    const out = { ...(base && typeof base === "object" && !Array.isArray(base) ? base : {}) };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === undefined)
+            continue;
+        out[k] = deepMerge(out[k], v);
+    }
+    return out;
+}
+function summarizeLink(l) {
+    const a = l.appearance;
+    return {
+        link_id: l._id,
+        name: l.name,
+        enabled: l.enabled,
+        url: l.hash ? demoUrl(l.hash) : null,
+        expiresAt: l.expiresAt ?? null,
+        perVisitorLimit: l.perIpLimit,
+        totalLimit: l.totalLimit,
+        showCountdownTimer: l.showCountdownTimer,
+        dynamicVariables: l.dynamicVariables,
+        pinnedDraft: l.draftId ? { draftId: l.draftId, draftName: l.draftName } : null,
+        page: a?.template === "custom" ? "custom" : "classic",
+        appearance: a ?? null,
+    };
+}
+const widgetDesignShape = {
+    mode: z
+        .enum(["voice", "text", "both"])
+        .optional()
+        .describe('"voice" = call button (default), "text" = chat, "both" = type-or-talk (one session the visitor can type or speak in)'),
+    placement: z.enum(["bottom-right", "bottom-left", "top-right", "top-left"]).optional(),
+    variant: z.enum(["compact", "expanded"]).optional(),
+    theme: z.enum(["light", "dark"]).optional(),
+    avatarStyle: z.enum(["orb", "image", "initials"]).optional().describe('"image" uses `avatar`'),
+    brandColor: hex.nullable().optional().describe("Main button colour"),
+    orbColor1: hex.nullable().optional().describe("Orb gradient start (avatarStyle orb)"),
+    orbColor2: hex.nullable().optional().describe("Orb gradient end"),
+    backgroundColor: hex.nullable().optional().describe("Card/panel background; null follows the theme"),
+    textColor: hex.nullable().optional(),
+    buttonTextColor: hex.nullable().optional(),
+    brandName: z.string().max(60).nullable().optional(),
+    brandLogo: httpsUrl.nullable().optional().describe("https image URL (rendered on the customer's site, so it must be public)"),
+    avatar: httpsUrl.nullable().optional().describe("https image URL for avatarStyle image"),
+    title: z.string().max(60).nullable().optional().describe("Header title (defaults to the agent name)"),
+    launcherText: z.string().max(40).nullable().optional().describe("Text on the collapsed launcher"),
+    greeting: z.string().max(280).nullable().optional().describe("Line shown above the input before a conversation"),
+    chatWelcome: z
+        .string()
+        .max(400)
+        .nullable()
+        .optional()
+        .describe("First agent message in chats (text/both). Replaces the flow's phone greeting for chats only"),
+    inputPlaceholder: z.string().max(80).nullable().optional(),
+    startCallText: z.string().max(30).nullable().optional(),
+    messageText: z.string().max(30).nullable().optional(),
+    suggestedPrompts: z.array(z.string().max(80)).max(4).optional().describe("Up to 4 quick-start chips"),
+    termsText: z
+        .string()
+        .max(2000)
+        .nullable()
+        .optional()
+        .describe("Markdown the visitor must accept before their first conversation"),
+    feedback: z.enum(["none", "end"]).optional().describe('"end" asks for thumbs up/down after a conversation'),
+};
+const demoAppearanceShape = {
+    template: z
+        .enum(["classic", "custom"])
+        .optional()
+        .describe('"custom" turns on the branded page; "classic" (default) is the original page and ignores every design field'),
+    brand: z
+        .object({
+        companyName: z.string().max(80).optional(),
+        logoPosition: z.enum(["left", "right"]).optional(),
+        logoSize: z.enum(["sm", "md", "lg"]).optional(),
+        colors: z
+            .object({
+            primary: hex.optional(),
+            background: hex.optional(),
+            surface: hex.optional(),
+            text: hex.optional(),
+            buttonText: hex.optional(),
+        })
+            .optional(),
+        font: z
+            .enum([
+            "Inter",
+            "Inter Tight",
+            "DM Sans",
+            "Manrope",
+            "Plus Jakarta Sans",
+            "Work Sans",
+            "Roboto",
+            "Open Sans",
+            "Lato",
+            "Poppins",
+            "Montserrat",
+            "Source Sans 3",
+            "IBM Plex Sans",
+            "Nunito Sans",
+            "Merriweather",
+            "Playfair Display",
+        ])
+            .optional(),
+        radius: z.enum(["sharp", "soft", "round"]).optional(),
+        edgeStripe: z.boolean().optional().describe("Thin primary-colour stripe along the page edge"),
+    })
+        .optional()
+        .describe("Logo and tab icon are NOT set here: use trillet_upload_demo_page_logo"),
+    content: z
+        .object({
+        headline: z.string().max(120).optional(),
+        subheadline: z.string().max(280).optional(),
+        agentName: z.string().max(60).optional(),
+        startLabel: z.string().max(40).optional(),
+        endedTitle: z.string().max(120).optional(),
+        endedMessage: z.string().max(280).optional(),
+        cta: z
+            .object({ label: z.string().max(40), url: z.string() })
+            .optional()
+            .describe("Button after the call; url must be https. Empty label removes it"),
+    })
+        .optional(),
+    features: z
+        .object({
+        liveTranscript: z.boolean().optional(),
+        callTimer: z.boolean().optional(),
+        postCallSummary: z.boolean().optional(),
+        postCallFields: z
+            .array(z.string())
+            .optional()
+            .describe("Post-call analysis field NAMES to show after the call; unknown names are dropped"),
+        callAgain: z.boolean().optional(),
+        muteButton: z.boolean().optional(),
+        poweredBy: z.boolean().optional(),
+    })
+        .optional(),
+    embed: z
+        .object({
+        allowedOrigins: z
+            .array(z.string())
+            .max(10)
+            .optional()
+            .describe("Sites that may iframe the page AND receive post-call results, as bare https origins (https://www.example.com)"),
+        allowLocalhost: z.boolean().optional().describe("Also allow http://localhost while the client builds"),
+    })
+        .optional(),
+};
+export function registerBrandingTools(server, client) {
+    // ── Website widget ──────────────────────────────────────────────────────
+    server.registerTool("trillet_get_website_widget", {
+        title: "Get website widget design",
+        description: "Read a call flow's website widget design (the <trillet-widget> embed: voice, chat or type-or-talk) plus the embed snippet to paste on a site. `saved: false` means defaults are in use. Visitors can only start conversations when publicAccess is on.",
+        inputSchema: { flow_id: z.string(), ...workspaceParam },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, guard(async ({ flow_id, workspace_id }) => {
+        const res = await client.request("GET", `/v1/api/call-flows/${flow_id}/widget`, {
+            workspaceId: workspace_id,
+        });
+        const ws = workspace_id || client.workspaceId;
+        return ok({
+            ...res,
+            embed_snippet: res.agentId ? widgetSnippet(res.agentId, ws) : null,
+        });
+    }));
+    server.registerTool("trillet_set_website_widget", {
+        title: "Design the website widget",
+        description: "Create or update a call flow's website widget design: voice/chat/type-or-talk mode, colours, logo, copy, suggested prompts, terms, feedback. Only the fields you pass change (the stored design is read and merged; null clears a field). Applies to live embeds immediately (not staged in a draft; existing embeds pick it up within about a minute). Attributes written on a site's <trillet-widget> tag override the saved design. Returns the embed snippet. Set public_access true unless the flow already allows public calls, or visitors get 403.",
+        inputSchema: {
+            flow_id: z.string(),
+            ...widgetDesignShape,
+            reset: z.boolean().default(false).describe("Start from defaults instead of the stored design"),
+            public_access: z
+                .boolean()
+                .optional()
+                .describe("Also set settings.security.publicAccess (required for website visitors)"),
+            ...workspaceParam,
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, guard(async ({ flow_id, reset, public_access, workspace_id, ...design }) => {
+        const current = await client.request("GET", `/v1/api/call-flows/${flow_id}/widget`, {
+            workspaceId: workspace_id,
+        });
+        const widget = deepMerge(reset ? {} : current.widget ?? {}, design);
+        const saved = await client.request("PUT", `/v1/api/call-flows/${flow_id}/widget`, {
+            body: { widget },
+            workspaceId: workspace_id,
+        });
+        let publicAccess = Boolean(current.publicAccess);
+        if (public_access !== undefined) {
+            await client.request("PUT", `/v1/api/call-flows/${flow_id}`, {
+                body: { settings: { security: { publicAccess: public_access } } },
+                workspaceId: workspace_id,
+            });
+            publicAccess = public_access;
+        }
+        const ws = workspace_id || client.workspaceId;
+        return ok({
+            widget: saved.widget,
+            publicAccess,
+            ...(publicAccess
+                ? {}
+                : { warning: "publicAccess is off: website visitors cannot start a conversation. Pass public_access: true." }),
+            embed_snippet: current.agentId ? widgetSnippet(current.agentId, ws) : null,
+        });
+    }));
+    // ── Demo links + custom demo page ───────────────────────────────────────
+    server.registerTool("trillet_list_demo_links", {
+        title: "List demo links",
+        description: `List a call flow's shareable demo links (max 5 per flow) with their URL, limits, and custom page design. ${DEMO_URL_NOTE} GOTCHA: while the flow has an active draft, this read shows the draft's copy of the links, which can be stale; has_active_draft flags it.`,
+        inputSchema: { flow_id: z.string(), ...workspaceParam },
+        annotations: { readOnlyHint: true, openWorldHint: true },
+    }, guard(async ({ flow_id, workspace_id }) => {
+        const res = await client.request("GET", `/v1/api/call-flows/${flow_id}`, { workspaceId: workspace_id });
+        const p = res.pathway ?? res;
+        const drafts = await client
+            .request("GET", `/v1/api/call-flows/${flow_id}/drafts`, { workspaceId: workspace_id })
+            .catch(() => []);
+        const draftList = Array.isArray(drafts) ? drafts : drafts.drafts ?? [];
+        return ok({
+            publicAccess: Boolean(p.settings?.security?.publicAccess),
+            has_active_draft: draftList.some((d) => d.isActive),
+            postCallFieldNames: (p.settings?.postCallAnalysis ?? []).map((f) => f?.name).filter(Boolean),
+            links: (p.settings?.publicDemoLinks ?? []).map(summarizeLink),
+        });
+    }));
+    server.registerTool("trillet_create_demo_link", {
+        title: "Create demo link",
+        description: `Create a shareable demo link for a call flow (anyone with the URL can talk to the agent in the browser). Saved to production immediately and turns publicAccess on. Max 5 links per flow. Optional usage caps protect the wallet: per_visitor_minutes and total_minutes. Style the page afterwards with trillet_set_demo_page_design and trillet_upload_demo_page_logo. ${DEMO_URL_NOTE}`,
+        inputSchema: {
+            flow_id: z.string(),
+            name: z.string().default("New Demo Link").describe("Internal label, shown in the dashboard"),
+            expires_in_days: z.number().int().positive().optional(),
+            per_visitor_minutes: z.number().int().positive().optional().describe("Cap per visitor (by IP); omit for no cap"),
+            total_minutes: z.number().int().positive().optional().describe("Cap across all visitors; omit for no cap"),
+            show_countdown_timer: z.boolean().default(false).describe("Show the remaining-minutes countdown on the page"),
+            dynamic_variables: z
+                .array(z.object({
+                key: z.string(),
+                mode: z.enum(["preset", "prompt"]).describe("preset = fixed value; prompt = the visitor fills it in before calling"),
+                value: z.string().optional().describe("preset only"),
+                label: z.string().optional().describe("prompt only"),
+                placeholder: z.string().optional(),
+                required: z.boolean().optional(),
+            }))
+                .optional()
+                .describe("{{variables}} the flow uses, filled per link"),
+            draft_id: z.string().optional().describe("Pin the link to a draft so it tests unpublished changes"),
+            ...workspaceParam,
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
+    }, guard(async (a) => {
+        const res = await client.request("POST", `/v1/api/call-flows/${a.flow_id}/demo/generate-hash`, {
+            body: {
+                name: a.name,
+                expiresInDays: a.expires_in_days,
+                perIpLimit: { enabled: a.per_visitor_minutes !== undefined, minutes: a.per_visitor_minutes ?? 5 },
+                totalLimit: { enabled: a.total_minutes !== undefined, minutes: a.total_minutes ?? 100 },
+                showCountdownTimer: a.show_countdown_timer,
+                dynamicVariables: a.dynamic_variables ?? [],
+                draftId: a.draft_id,
+            },
+            workspaceId: a.workspace_id,
+        });
+        const link = res.demoLink ?? res;
+        return ok({ ...summarizeLink(link), iframe_snippet: iframeSnippet(link.hash, link.name) });
+    }));
+    server.registerTool("trillet_set_demo_page_design", {
+        title: "Design a demo link's page",
+        description: "Brand one demo link's page: template custom, colours, font, corner radius, copy, CTA button, which features show (live transcript, timer, post-call summary and chosen post-call answers, call again, mute, Powered by), and which sites may iframe it and receive results. Only the fields you pass change (the stored design is read and merged). Live immediately. Set template \"custom\" or nothing shows. Upload the logo or tab icon with trillet_upload_demo_page_logo. Returns the page URL and an iframe snippet (?embed=1 = transparent background + trillet-demo:* postMessage events).",
+        inputSchema: {
+            flow_id: z.string(),
+            link_id: z.string().describe("link_id from trillet_list_demo_links / trillet_create_demo_link"),
+            ...demoAppearanceShape,
+            clear_logo: z.boolean().optional(),
+            clear_favicon: z.boolean().optional(),
+            reset: z.boolean().default(false).describe("Start from defaults instead of the stored design (keeps the uploaded logo unless clear_logo)"),
+            ...workspaceParam,
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, guard(async ({ flow_id, link_id, clear_logo, clear_favicon, reset, workspace_id, ...patch }) => {
+        const res = await client.request("GET", `/v1/api/call-flows/${flow_id}`, { workspaceId: workspace_id });
+        const p = res.pathway ?? res;
+        const link = (p.settings?.publicDemoLinks ?? []).find((l) => String(l?._id) === link_id);
+        if (!link && !reset) {
+            throw new Error("Demo link not found on this flow's current view. If the flow has an active draft, its stale copy hides newer links: run trillet_deactivate_drafts, or retry with reset: true to send a full design without reading the stored one.");
+        }
+        // Prefer production's copy of the design (the flow GET overlays an active
+        // draft's settings). The public page route reads production directly.
+        let stored = link?.appearance ?? {};
+        if (link?.hash && link.enabled) {
+            const pub = await client
+                .request("GET", `/v1/api/public/demo/${link.hash}/info`, { workspaceId: workspace_id })
+                .catch(() => null);
+            if (pub?.appearance) {
+                stored = {
+                    ...pub.appearance,
+                    features: {
+                        ...pub.appearance.features,
+                        postCallFields: (pub.appearance.features?.postCallFields ?? []).map((f) => f?.name ?? f),
+                    },
+                };
+            }
+        }
+        const appearance = deepMerge(reset ? {} : stored, patch);
+        // The backend keeps the uploaded images unless told to clear them.
+        appearance.brand = { ...(appearance.brand ?? {}) };
+        delete appearance.brand.logo;
+        delete appearance.brand.favicon;
+        if (clear_logo)
+            appearance.brand.logo = null;
+        if (clear_favicon)
+            appearance.brand.favicon = null;
+        const saved = await client.request("PUT", `/v1/api/call-flows/${flow_id}/demo-links/${link_id}/appearance`, { body: { appearance }, workspaceId: workspace_id });
+        const hash = link?.hash;
+        return ok({
+            appearance: saved.appearance,
+            ...(hash ? { url: demoUrl(hash), iframe_snippet: iframeSnippet(hash, link.name ?? "Demo") } : {}),
+            ...(saved.appearance?.template !== "custom"
+                ? { note: 'template is "classic": the design is stored but the original page shows until template is "custom".' }
+                : {}),
+        });
+    }));
+    server.registerTool("trillet_upload_demo_page_logo", {
+        title: "Upload demo page logo or tab icon",
+        description: "Upload the logo (or, with kind favicon, the browser-tab icon) for one demo link's custom page. PNG, JPG or WebP under 2MB; SVG is rejected. Pass a local file_path or an https image_url (downloaded here, then uploaded). Live immediately. The returned logo url is a public https image, so it can also be reused as the website widget's brandLogo.",
+        inputSchema: {
+            flow_id: z.string(),
+            link_id: z.string(),
+            file_path: z.string().optional().describe("Absolute path to a local PNG/JPG/WebP"),
+            image_url: z.string().optional().describe("https URL of the image, e.g. from the client's website"),
+            kind: z.enum(["logo", "favicon"]).default("logo"),
+            ...workspaceParam,
+        },
+        annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+    }, guard(async ({ flow_id, link_id, file_path, image_url, kind, workspace_id }) => {
+        const { data, name } = await loadImage(file_path, image_url);
+        if (data.length > MAX_IMAGE_BYTES)
+            throw new Error("Image must be under 2MB.");
+        const type = sniffImage(data);
+        if (!type)
+            throw new Error("Image must be a PNG, JPG or WebP (SVG and other formats are rejected).");
+        const filename = name.includes(".") ? name : `${name}.${type.ext}`;
+        const query = kind === "favicon" ? "?kind=favicon" : "";
+        const res = await client.upload(`/v1/api/call-flows/${flow_id}/demo-links/${link_id}/logo${query}`, "file", filename, data, type.mime, workspace_id);
+        return ok({ [kind]: res[kind], template: res.appearance?.template });
+    }));
+}

package/dist/version.js

@@ -4,4 +4,4 @@
  * with .claude-plugin/plugin.json, mcpb/manifest.json, and package.json when
  * releasing (see README "Maintainers").
  */
-export const VERSION = "0.7.3";
+export const VERSION = "0.8.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trillet-ai/mcp",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "description": "Official Trillet AI MCP server: build and manage voice agents, call flows, in-call API tools, knowledge bases, workflows, and call history from Claude.",
   "license": "MIT",
   "type": "module",