@rymi/mcp 2.0.0 → 2.1.0

package/README.md

@@ -76,6 +76,14 @@ Run the server on your own machine — it speaks **stdio** by default and talks
 <td><code>list_agents</code> · <code>get_agent</code> · <code>create_agent</code> · <code>update_agent</code> · <code>delete_agent</code> · <code>clone_agent</code> · <code>apply_agent_changes</code> · <code>generate_agent_draft</code> · <code>enrich_company</code> · <code>validate_agent_publish</code> · <code>preview_stack</code></td>
 </tr>
 <tr>
+<td><b>API tools & secrets</b></td>
+<td><code>list_agent_tools</code> · <code>add_agent_tool</code> · <code>update_agent_tool</code> · <code>remove_agent_tool</code> · <code>list_tool_secrets</code> · <code>set_tool_secret</code></td>
+</tr>
+<tr>
+<td><b>Share link</b></td>
+<td><code>get_share_link</code> · <code>set_share_link</code> · <code>regenerate_share_link</code></td>
+</tr>
+<tr>
 <td><b>Discovery</b></td>
 <td><code>list_llm_options</code> · <code>list_voices</code></td>
 </tr>

package/dist/index.js

@@ -6,9 +6,16 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
     for (let key of __getOwnPropNames(from))
@@ -25,6 +32,260 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../shared-types/dist/agentTools.js
+var agentTools_exports = {};
+__export(agentTools_exports, {
+  API_SECRETS_PROVIDER: () => API_SECRETS_PROVIDER,
+  API_TOOL_AUTH_HEADER_PATTERN: () => API_TOOL_AUTH_HEADER_PATTERN,
+  API_TOOL_NAME_PATTERN: () => API_TOOL_NAME_PATTERN,
+  API_TOOL_RESERVED_FIELD_NAMES: () => API_TOOL_RESERVED_FIELD_NAMES,
+  API_TOOL_SECRET_REF_PATTERN: () => API_TOOL_SECRET_REF_PATTERN,
+  BUILTIN_TOOL_CATALOG: () => BUILTIN_TOOL_CATALOG,
+  SECRET_NAME_PATTERN: () => SECRET_NAME_PATTERN,
+  toToolCapabilitySafeView: () => toToolCapabilitySafeView
+});
+function toToolCapabilitySafeView(state) {
+  return {
+    toolId: state.toolId,
+    available: state.authorized && state.runtimeRegistered,
+    unavailableReason: state.unavailableReason,
+    sideEffect: state.sideEffect
+  };
+}
+var API_TOOL_NAME_PATTERN, SECRET_NAME_PATTERN, API_SECRETS_PROVIDER, API_TOOL_RESERVED_FIELD_NAMES, API_TOOL_AUTH_HEADER_PATTERN, API_TOOL_SECRET_REF_PATTERN, BUILTIN_TOOL_CATALOG;
+var init_agentTools = __esm({
+  "../shared-types/dist/agentTools.js"() {
+    "use strict";
+    API_TOOL_NAME_PATTERN = /^[a-z][a-z0-9_]{2,40}$/;
+    SECRET_NAME_PATTERN = /^[A-Z][A-Z0-9_]{1,63}$/;
+    API_SECRETS_PROVIDER = "api_secrets";
+    API_TOOL_RESERVED_FIELD_NAMES = /* @__PURE__ */ new Set([
+      "False",
+      "None",
+      "True",
+      "and",
+      "as",
+      "assert",
+      "async",
+      "await",
+      "break",
+      "class",
+      "continue",
+      "def",
+      "del",
+      "elif",
+      "else",
+      "except",
+      "finally",
+      "for",
+      "from",
+      "global",
+      "if",
+      "import",
+      "in",
+      "is",
+      "lambda",
+      "nonlocal",
+      "not",
+      "or",
+      "pass",
+      "raise",
+      "return",
+      "try",
+      "while",
+      "with",
+      "yield",
+      "params"
+    ]);
+    API_TOOL_AUTH_HEADER_PATTERN = /^(authorization|x-api-key|api[-_]?key|.*token.*|.*secret.*)$/i;
+    API_TOOL_SECRET_REF_PATTERN = /\{\{\s*secrets\.[A-Z][A-Z0-9_]{1,63}\s*\}\}/;
+    BUILTIN_TOOL_CATALOG = [
+      {
+        tool_id: "handoff_to_human",
+        label: "Human handoff",
+        description: "Transfer the live call to the configured human destination when escalation is required.",
+        category: "call_control",
+        side_effect: "write",
+        default_timeout_ms: 1e3,
+        requires_credential: false
+      },
+      {
+        tool_id: "check_calendar_availability",
+        label: "Check calendar availability",
+        description: "Look up open slots in the configured calendar provider.",
+        category: "calendar",
+        side_effect: "read",
+        default_timeout_ms: 4e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "list_calendar_events",
+        label: "List calendar events",
+        description: "Read scheduled events from the configured calendar provider.",
+        category: "calendar",
+        side_effect: "read",
+        default_timeout_ms: 4e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "create_calendar_event",
+        label: "Create calendar event",
+        description: "Create a calendar event after the caller explicitly confirms the details.",
+        category: "calendar",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "update_calendar_event",
+        label: "Update calendar event",
+        description: "Move or edit an existing calendar event after explicit caller confirmation.",
+        category: "calendar",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "delete_calendar_event",
+        label: "Delete calendar event",
+        description: "Cancel an existing calendar event after explicit caller confirmation.",
+        category: "calendar",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "lookup_customer",
+        label: "Look up customer",
+        description: "Find a customer record by phone, email, or external id.",
+        category: "crm",
+        side_effect: "read",
+        default_timeout_ms: 4e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "send_whatsapp_message",
+        label: "Send WhatsApp message",
+        description: "Send a WhatsApp message to the caller mid-call (e.g. confirmation link, address, brochure URL). Outside the 24h customer-care window an approved template must be configured.",
+        category: "messaging",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "send_telegram_message",
+        label: "Send Telegram message",
+        description: "Send a Telegram bot message to the caller mid-call. Requires the caller to have an established chat_id with the tenant's bot (no cold-send by phone).",
+        category: "messaging",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "send_asset",
+        label: "Send asset",
+        description: "Send a configured shareable asset to the caller when they explicitly request a document, brochure, or guide.",
+        category: "messaging",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "lookup_ticket",
+        label: "Look up ticket",
+        description: "Find a support ticket by its number, or the caller's most recent ticket, and read back its status.",
+        category: "ticketing",
+        side_effect: "read",
+        default_timeout_ms: 4e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "create_ticket",
+        label: "Create ticket",
+        description: "Raise a support ticket from the call after the caller confirms the details, and read the ticket number back to them.",
+        category: "ticketing",
+        side_effect: "write",
+        default_timeout_ms: 6e3,
+        requires_credential: true
+      },
+      {
+        tool_id: "call_webhook",
+        label: "API request",
+        description: "Call your own HTTPS API mid-call, to look something up or to send details. Each API tool has its own name, purpose, typed parameters and headers; header secrets stay encrypted.",
+        category: "webhook",
+        side_effect: "read",
+        default_timeout_ms: 6e3,
+        // The endpoint lives in the binding's provider_settings and its secrets in
+        // the tenant's api_secrets row — nothing to connect in Settings → Connectors.
+        requires_credential: false
+      }
+    ];
+  }
+});
+
+// ../shared-types/dist/safeUrl.js
+var safeUrl_exports = {};
+__export(safeUrl_exports, {
+  isSafeUrl: () => isSafeUrl
+});
+function unmapIpv4(v6) {
+  const dotted = /^::ffff:(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(v6);
+  if (dotted)
+    return dotted[1];
+  const hex = /^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/.exec(v6);
+  if (!hex)
+    return null;
+  const high = parseInt(hex[1], 16);
+  const low = parseInt(hex[2], 16);
+  return [high >> 8, high & 255, low >> 8, low & 255].join(".");
+}
+function isBlockedHost(host) {
+  const bare = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
+  if (bare === "localhost" || bare === "0.0.0.0" || bare === "::")
+    return true;
+  if (bare.endsWith(".local") || bare.endsWith(".internal") || bare.endsWith(".localhost"))
+    return true;
+  if (/^127\./.test(bare))
+    return true;
+  if (/^10\./.test(bare))
+    return true;
+  if (/^192\.168\./.test(bare))
+    return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\./.test(bare))
+    return true;
+  if (/^169\.254\./.test(bare))
+    return true;
+  const v6 = bare.toLowerCase();
+  if (v6 === "::1")
+    return true;
+  if (/^f[cd][0-9a-f]{2}:/.test(v6))
+    return true;
+  if (/^fe[89ab][0-9a-f]:/.test(v6))
+    return true;
+  const mapped = unmapIpv4(v6);
+  if (mapped)
+    return isBlockedHost(mapped);
+  return false;
+}
+function isSafeUrl(raw, options = {}) {
+  const protocols = options.protocols ?? ["http:", "https:"];
+  let url;
+  try {
+    url = new URL(raw);
+  } catch {
+    return false;
+  }
+  if (!protocols.includes(url.protocol))
+    return false;
+  return !isBlockedHost(url.hostname.toLowerCase());
+}
+var init_safeUrl = __esm({
+  "../shared-types/dist/safeUrl.js"() {
+    "use strict";
+  }
+});
 
 // ../ops-tools/dist/index.js
 var require_dist = __commonJS({
@@ -34,7 +295,7 @@ var require_dist = __commonJS({
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
     var __getOwnPropNames2 = Object.getOwnPropertyNames;
     var __hasOwnProp2 = Object.prototype.hasOwnProperty;
-    var __export = (target, all) => {
+    var __export2 = (target, all) => {
       for (var name in all)
         __defProp2(target, name, { get: all[name], enumerable: true });
     };
@@ -46,14 +307,14 @@ var require_dist = __commonJS({
       }
       return to;
     };
-    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
     var index_exports = {};
-    __export(index_exports, {
+    __export2(index_exports, {
       defineTool: () => defineTool,
       opsToolCatalog: () => opsToolCatalog2,
       resolveToolDisposition: () => resolveToolDisposition
     });
-    module2.exports = __toCommonJS(index_exports);
+    module2.exports = __toCommonJS2(index_exports);
     function defineTool(def) {
       return def;
     }
@@ -64,6 +325,20 @@ var require_dist = __commonJS({
       return p.risk === "write" ? "propose" : "confirm";
     }
     var import_zod = require("zod");
+    var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    var norm = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
+    async function resolveAgentId(client, agentId) {
+      const raw = String(agentId ?? "").trim();
+      if (UUID_RE.test(raw)) return raw;
+      const { agents } = await client.agents.list({ limit: 500 });
+      const target = norm(raw);
+      const matches = agents.filter((a) => norm(a.name ?? "") === target);
+      if (matches.length === 1) return matches[0].id;
+      if (matches.length > 1) {
+        throw new Error(`"${raw}" matches ${matches.length} agents \u2014 call list_agents and pass the exact agent UUID.`);
+      }
+      throw new Error(`No agent named "${raw}" found \u2014 call list_agents to get a valid agent UUID.`);
+    }
     var agentConfigFields = {
       system_prompt: import_zod.z.string().optional().describe("Full system prompt for the agent. If given without persona/playbook, the server auto-structures it."),
       voice: import_zod.z.string().optional().describe('Voice ID (e.g. "Aoede", "Charon"). Call list_llm_options for valid values. Leave empty for realtime LLMs and Deepgram TTS, which carry their own voice.'),
@@ -86,7 +361,7 @@ var require_dist = __commonJS({
       custom_voice_mode: import_zod.z.enum(["rymi", "openai-compat"]).optional().describe("Wire format for custom_voice_url."),
       custom_transcriber_url: import_zod.z.string().nullable().optional().describe("Self-hosted STT endpoint (https:// or wss://). Enterprise only; null clears."),
       prompt_mode: import_zod.z.enum(["builder", "raw"]).optional().describe('How the system prompt is interpreted: "builder" (server structures persona/playbook from system_prompt) or "raw" (use system_prompt verbatim \u2014 requires system_prompt). Defaults to "builder".'),
-      persona: import_zod.z.record(import_zod.z.any()).optional().describe("Persona object. Note: callerPersonas must be objects of shape {type, approach, detectedWhen}, NOT plain strings."),
+      persona: import_zod.z.record(import_zod.z.any()).optional().describe("Persona object. persona.name is the name the agent speaks and introduces itself as (also shown on share/tester pages); it defaults to the label when omitted. Note: callerPersonas must be objects of shape {type, approach, detectedWhen}, NOT plain strings."),
       playbook: import_zod.z.record(import_zod.z.any()).optional().describe("Playbook configuration object"),
       advanced: import_zod.z.record(import_zod.z.any()).optional(),
       features: import_zod.z.record(import_zod.z.any()).optional(),
@@ -97,6 +372,25 @@ var require_dist = __commonJS({
       if (!prompt_mode) return rest;
       return { ...rest, advanced: { ...rest.advanced || {}, prompt_mode } };
     }
+    var LLM_PROVIDER_ALIASES = {
+      google: "gemini",
+      googleai: "gemini",
+      "google-genai": "gemini",
+      "google-ai": "gemini",
+      vertex: "gemini",
+      vertexai: "gemini",
+      "vertex-ai": "gemini",
+      claude: "anthropic",
+      gpt: "openai",
+      "azure-openai": "openai",
+      azure: "openai"
+    };
+    function normalizeLlmProvider(params) {
+      const p = params.llm_provider;
+      if (!p) return params;
+      const alias = LLM_PROVIDER_ALIASES[p.toLowerCase()];
+      return alias ? { ...params, llm_provider: alias } : params;
+    }
     var agentTools = [
       defineTool({
         name: "list_agents",
@@ -248,10 +542,10 @@ var require_dist = __commonJS({
         scope: "agent",
         risk: "write",
         input: {
-          name: import_zod.z.string().min(1).describe("Agent display name"),
+          name: import_zod.z.string().min(1).describe("Studio label: the name shown in the sidebar/agent list only. The name the agent speaks is persona.name."),
           ...agentConfigFields
         },
-        run: (client, params) => client.agents.create(foldPromptMode(params))
+        run: (client, params) => client.agents.create(normalizeLlmProvider(foldPromptMode(params)))
       }),
       defineTool({
         name: "update_agent",
@@ -260,11 +554,11 @@ var require_dist = __commonJS({
         risk: "write",
         input: {
           agent_id: import_zod.z.string().uuid().describe("The agent UUID to update"),
-          name: import_zod.z.string().optional(),
+          name: import_zod.z.string().optional().describe("Studio label (sidebar/agent list only). To change the spoken name, set persona.name."),
           ...agentConfigFields,
           chat_summary: import_zod.z.string().nullable().optional()
         },
-        run: (client, { agent_id, ...params }) => client.agents.update(agent_id, foldPromptMode(params))
+        run: async (client, { agent_id, ...params }) => client.agents.update(await resolveAgentId(client, agent_id), normalizeLlmProvider(foldPromptMode(params)))
       }),
       defineTool({
         name: "delete_agent",
@@ -272,7 +566,7 @@ var require_dist = __commonJS({
         scope: "agent",
         risk: "sensitive",
         input: { agent_id: import_zod.z.string().uuid().describe("The agent UUID to delete") },
-        run: (client, { agent_id }) => client.agents.delete(agent_id)
+        run: async (client, { agent_id }) => client.agents.delete(await resolveAgentId(client, agent_id))
       }),
       defineTool({
         name: "clone_agent",
@@ -280,7 +574,7 @@ var require_dist = __commonJS({
         scope: "agent",
         risk: "write",
         input: { agent_id: import_zod.z.string().uuid().describe("The agent UUID to clone") },
-        run: (client, { agent_id }) => client.agents.clone(agent_id)
+        run: async (client, { agent_id }) => client.agents.clone(await resolveAgentId(client, agent_id))
       })
     ];
     var import_zod2 = require("zod");
@@ -642,7 +936,7 @@ var require_dist = __commonJS({
         // handler, a published:false-with-blockers response is NOT flagged as a
         // protocol error — blockers are valid data every consumer (MCP client,
         // studio harness) reads from the result directly.
-        run: (client, { agent_id }) => client.agents.publish(agent_id)
+        run: async (client, { agent_id }) => client.agents.publish(await resolveAgentId(client, agent_id))
       })
     ];
     var import_zod7 = require("zod");
@@ -935,8 +1229,277 @@ var require_dist = __commonJS({
         run: (client, { campaign_id, suggestion_id }) => client.campaigns.acceptSuggestion(campaign_id, suggestion_id)
       })
     ];
+    var import_zod11 = require("zod");
+    var import_agentTools = (init_agentTools(), __toCommonJS(agentTools_exports));
+    var import_safeUrl = (init_safeUrl(), __toCommonJS(safeUrl_exports));
+    var DEFAULT_NAME = "call_webhook";
+    var METHODS = ["GET", "POST", "PUT", "PATCH"];
+    var FIELD_NAME = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+    var RESERVED_HEADERS = /* @__PURE__ */ new Set(["host", "content-length", "connection", "transfer-encoding"]);
+    var LIVE_NOTE = "Saved to the live agent row: the voice runtime uses it from the next call. There is no separate draft; publish_agent is not required. Undo with list_agent_changes \u2192 undo_agent_change.";
+    var fieldSchema = import_zod11.z.object({
+      name: import_zod11.z.string().describe('Argument name the agent fills in: letters, digits, underscores; not a Python keyword or "params".'),
+      type: import_zod11.z.enum(["string", "number", "integer", "boolean"]).optional().describe('Default "string".'),
+      description: import_zod11.z.string().optional().describe("What the value is, for the agent."),
+      required: import_zod11.z.boolean().optional(),
+      enum: import_zod11.z.array(import_zod11.z.string()).optional().describe("Allowed values, if fixed.")
+    });
+    var settingsShape = {
+      url: import_zod11.z.string().describe("Public https endpoint. Private, loopback and non-https hosts are refused."),
+      method: import_zod11.z.enum(METHODS).optional().describe("Default POST. GET sends fields as query parameters."),
+      purpose: import_zod11.z.string().optional().describe("When the agent should call this tool. Without it the agent rarely fires it."),
+      fields: import_zod11.z.array(fieldSchema).optional().describe("Arguments the agent supplies. Replaces the whole list on update."),
+      headers: import_zod11.z.record(import_zod11.z.string()).optional().describe("Request headers. Credentials must be a {{secrets.NAME}} reference (see set_tool_secret), never a literal key."),
+      send_metadata: import_zod11.z.boolean().optional().describe("Include call metadata (call id, agent id, caller phone). Default true."),
+      response_fields: import_zod11.z.array(import_zod11.z.string()).optional().describe("Dot paths kept from the JSON response; default keeps the (truncated) body."),
+      timeout_ms: import_zod11.z.number().int().min(1e3).max(1e4).optional().describe("Per-request timeout, 1000\u201310000 ms. Default 6000."),
+      enabled: import_zod11.z.boolean().optional().describe("Default true.")
+    };
+    function bindingName(b) {
+      const n = b?.provider_settings?.name;
+      return typeof n === "string" && n.trim() ? n.trim() : DEFAULT_NAME;
+    }
+    var isApiTool = (b) => b?.tool_id === "call_webhook";
+    function webhookBindingErrors(b, opts) {
+      const errors = [];
+      const s = b.provider_settings ?? {};
+      const name = bindingName(b);
+      if (!import_agentTools.API_TOOL_NAME_PATTERN.test(name)) errors.push(`name "${name}": lowercase letters, digits and underscores, starting with a letter, 3\u201341 characters.`);
+      if (opts.otherNames.includes(name)) errors.push(`name "${name}" is already used by another API tool on this agent.`);
+      const url = typeof s.url === "string" ? s.url.trim() : "";
+      if (!url) errors.push("url is required.");
+      else if (!/^https:\/\//i.test(url)) errors.push("url must be https \u2014 the request carries caller details.");
+      else if (!(0, import_safeUrl.isSafeUrl)(url, { protocols: ["https:"] })) errors.push("url must be a valid public host; private and loopback addresses are refused at call time.");
+      if (!METHODS.includes(s.method)) errors.push(`method must be one of ${METHODS.join(", ")}.`);
+      if (!Number.isInteger(b.timeout_ms) || b.timeout_ms < 1e3 || b.timeout_ms > 1e4) errors.push("timeout_ms must be an integer from 1000 to 10000.");
+      const seen = /* @__PURE__ */ new Set();
+      for (const f of Array.isArray(s.fields) ? s.fields : []) {
+        const fname = typeof f?.name === "string" ? f.name.trim() : "";
+        if (!FIELD_NAME.test(fname)) errors.push(`field "${fname}": letters, digits and underscores only, not starting with a digit.`);
+        else if (import_agentTools.API_TOOL_RESERVED_FIELD_NAMES.has(fname)) errors.push(`field "${fname}" is reserved; use e.g. ${fname}_value.`);
+        else if (seen.has(fname)) errors.push(`field "${fname}" is duplicated.`);
+        seen.add(fname);
+      }
+      const headers = s.headers ?? {};
+      for (const key of opts.checkHeaders) {
+        const value = headers[key];
+        if (RESERVED_HEADERS.has(key.trim().toLowerCase())) errors.push(`header "${key}" is set by the runtime and cannot be overridden.`);
+        else if (typeof value !== "string") errors.push(`header "${key}" must be a string.`);
+        else if (import_agentTools.API_TOOL_AUTH_HEADER_PATTERN.test(key.trim()) && !import_agentTools.API_TOOL_SECRET_REF_PATTERN.test(value)) {
+          errors.push(`header "${key}" holds a literal credential. Store it with set_tool_secret and use "{{secrets.NAME}}" instead.`);
+        }
+      }
+      return errors;
+    }
+    function assertValid(b, tools, self, checkHeaders) {
+      const otherNames = tools.filter((t) => isApiTool(t) && t !== self).map(bindingName);
+      const errors = webhookBindingErrors(b, { otherNames, checkHeaders });
+      if (errors.length) throw new Error(`Invalid API tool binding: ${errors.join(" ")}`);
+    }
+    async function writeTools(client, agentRef, mutate) {
+      const agentId = await resolveAgentId(client, agentRef);
+      const agent = await client.agents.retrieve(agentId);
+      if (!Array.isArray(agent.tools)) throw new Error("The API did not return this agent's tool bindings, so a write could delete them. Refusing.");
+      const tools = mutate(agent.tools);
+      await client.agents.update(agentId, { tools });
+      return { agentId, tools };
+    }
+    function findApiTool(tools, name) {
+      const found = tools.find((t) => isApiTool(t) && bindingName(t) === name);
+      if (!found) {
+        const names2 = tools.filter(isApiTool).map(bindingName);
+        throw new Error(`No API tool named "${name}" on this agent. Existing: ${names2.length ? names2.join(", ") : "none"}.`);
+      }
+      return found;
+    }
+    var addShape = { agent_id: import_zod11.z.string().describe("The agent UUID"), name: import_zod11.z.string().describe('LLM-facing tool name, e.g. "lookup_reservation". Unique per agent.'), ...settingsShape };
+    var updateShape = {
+      agent_id: import_zod11.z.string().describe("The agent UUID"),
+      name: import_zod11.z.string().describe("Current name of the API tool to change."),
+      new_name: import_zod11.z.string().optional().describe("Rename the tool."),
+      ...settingsShape,
+      url: settingsShape.url.optional(),
+      headers: import_zod11.z.record(import_zod11.z.string().nullable()).optional().describe("Merged into the existing headers by name; null removes one. Headers you omit \u2014 including ones shown as [redacted] \u2014 are kept unchanged.")
+    };
+    var agentToolBindingTools = [
+      defineTool({
+        name: "list_agent_tools",
+        description: "List an agent's tool bindings (API tools / call_webhook, handoff, calendar, \u2026). Header values are shown only as {{secrets.NAME}} references; literal values are [redacted].",
+        scope: "agent",
+        risk: "read",
+        input: { agent_id: import_zod11.z.string().describe("The agent UUID") },
+        run: async (client, { agent_id }) => {
+          const agentId = await resolveAgentId(client, agent_id);
+          const agent = await client.agents.retrieve(agentId);
+          return { agent_id: agentId, tools: agent.tools ?? [] };
+        }
+      }),
+      defineTool({
+        name: "add_agent_tool",
+        description: `Add an API tool (call_webhook) to an agent, keeping its existing tools. The agent can then call the endpoint mid-call with the fields you define. ${LIVE_NOTE}`,
+        scope: "agent",
+        risk: "write",
+        input: addShape,
+        run: async (client, params) => {
+          const p = import_zod11.z.object(addShape).parse(params);
+          const binding = {
+            tool_id: "call_webhook",
+            enabled: p.enabled ?? true,
+            credential_ref: null,
+            timeout_ms: p.timeout_ms ?? 6e3,
+            side_effect: (p.method ?? "POST") === "GET" ? "read" : "write",
+            provider_settings: {
+              name: p.name.trim(),
+              url: p.url.trim(),
+              method: p.method ?? "POST",
+              send_metadata: p.send_metadata ?? true,
+              ...p.purpose ? { purpose: p.purpose } : {},
+              ...p.fields?.length ? { fields: p.fields } : {},
+              ...p.headers && Object.keys(p.headers).length ? { headers: p.headers } : {},
+              ...p.response_fields?.length ? { response_fields: p.response_fields } : {}
+            }
+          };
+          const { agentId } = await writeTools(client, p.agent_id, (tools) => {
+            assertValid(binding, tools, null, Object.keys(p.headers ?? {}));
+            return [...tools, binding];
+          });
+          return { status: "added", agent_id: agentId, tool: binding, note: LIVE_NOTE };
+        }
+      }),
+      defineTool({
+        name: "update_agent_tool",
+        description: `Change one API tool (call_webhook) on an agent by name. Only the settings you pass change; fields replaces the whole list, headers merge by name. ${LIVE_NOTE}`,
+        scope: "agent",
+        risk: "write",
+        input: updateShape,
+        run: async (client, params) => {
+          const p = import_zod11.z.object(updateShape).parse(params);
+          let updated = null;
+          const { agentId } = await writeTools(client, p.agent_id, (tools) => {
+            const current = findApiTool(tools, p.name);
+            const prev = current.provider_settings ?? {};
+            const headers = { ...prev.headers ?? {} };
+            for (const [k, v] of Object.entries(p.headers ?? {})) {
+              if (v === null) delete headers[k];
+              else headers[k] = v;
+            }
+            const settings = { ...prev, name: (p.new_name ?? bindingName(current)).trim() };
+            for (const key of ["url", "method", "purpose", "fields", "send_metadata", "response_fields"]) {
+              if (p[key] !== void 0) settings[key] = key === "url" ? p.url.trim() : p[key];
+            }
+            settings.method ??= "POST";
+            if (Object.keys(headers).length) settings.headers = headers;
+            else delete settings.headers;
+            const next = {
+              ...current,
+              enabled: p.enabled ?? current.enabled,
+              timeout_ms: p.timeout_ms ?? current.timeout_ms,
+              side_effect: settings.method === "GET" ? "read" : "write",
+              provider_settings: settings
+            };
+            const touched = Object.entries(p.headers ?? {}).filter(([, v]) => v !== null).map(([k]) => k);
+            assertValid(next, tools, current, touched);
+            updated = next;
+            return tools.map((t) => t === current ? next : t);
+          });
+          return { status: "updated", agent_id: agentId, tool: updated, note: LIVE_NOTE };
+        }
+      }),
+      defineTool({
+        name: "remove_agent_tool",
+        description: `Remove one API tool (call_webhook) from an agent by name, keeping its other tools. ${LIVE_NOTE}`,
+        scope: "agent",
+        risk: "write",
+        input: { agent_id: import_zod11.z.string().describe("The agent UUID"), name: import_zod11.z.string().describe("Name of the API tool to remove.") },
+        run: async (client, { agent_id, name }) => {
+          const { agentId, tools } = await writeTools(client, agent_id, (tools2) => {
+            const target = findApiTool(tools2, name);
+            return tools2.filter((t) => t !== target);
+          });
+          return { status: "removed", agent_id: agentId, name, remaining: tools.filter(isApiTool).map(bindingName), note: LIVE_NOTE };
+        }
+      }),
+      defineTool({
+        name: "list_tool_secrets",
+        description: "List the workspace's API-tool secret names and the host each is pinned to. Values are never returned.",
+        scope: "account",
+        risk: "read",
+        input: {},
+        run: (client) => client.toolSecrets.list()
+      }),
+      defineTool({
+        name: "set_tool_secret",
+        description: 'Create or replace a workspace secret for API-tool headers, referenced as "{{secrets.NAME}}" (e.g. header x-api-key: "{{secrets.RESERVATIONS_API_KEY}}"). The value is encrypted, write-only, and only ever sent to `host`. Replacing an existing name changes it for every agent that references it.',
+        scope: "account",
+        risk: "sensitive",
+        input: {
+          name: import_zod11.z.string().describe("UPPER_SNAKE_CASE, 2\u201364 characters."),
+          value: import_zod11.z.string().min(1).max(4096).describe("The secret value. Never echoed back."),
+          host: import_zod11.z.string().describe('Public hostname the secret may be sent to, e.g. "api.example.com".')
+        },
+        run: async (client, { name, value, host }) => {
+          if (!import_agentTools.SECRET_NAME_PATTERN.test(name)) throw new Error("Secret names are UPPER_SNAKE_CASE, 2\u201364 characters, starting with a letter.");
+          await client.toolSecrets.set(name, { value, host });
+          return { status: "saved", name, reference: `{{secrets.${name}}}` };
+        }
+      })
+    ];
+    var import_zod12 = require("zod");
+    var shareLinkTools = [
+      defineTool({
+        name: "get_share_link",
+        description: "Get an agent's public share link (URL, limits, minutes used). Returns link: null if none exists yet.",
+        scope: "agent",
+        risk: "read",
+        input: { agent_id: import_zod12.z.string().uuid().describe("The agent UUID") },
+        run: (client, { agent_id }) => client.agents.getShareLink(agent_id)
+      }),
+      defineTool({
+        name: "set_share_link",
+        description: "Create an agent's public share link, or update its settings. Anyone with the URL can talk to the agent in a browser, billed to this workspace. Defaults on create: 30-minute pool, 300 s per call, 2 concurrent calls, 3 calls per IP per hour. Set enabled=false to switch the link off.",
+        scope: "agent",
+        risk: "sensitive",
+        input: {
+          agent_id: import_zod12.z.string().uuid().describe("The agent UUID"),
+          enabled: import_zod12.z.boolean().optional().describe("Turn the link on or off"),
+          minutes_limit: import_zod12.z.number().int().min(0).max(6e3).optional().describe("Total talk-time pool in minutes"),
+          max_call_seconds: import_zod12.z.number().int().min(60).max(1800).optional().describe("Per-call cap in seconds"),
+          max_concurrent: import_zod12.z.number().int().min(1).max(10).optional().describe("Simultaneous calls"),
+          calls_per_ip_hour: import_zod12.z.number().int().min(1).max(30).optional().describe("Calls per caller IP per hour")
+        },
+        run: (client, { agent_id, ...settings }) => client.agents.setShareLink(agent_id, settings)
+      }),
+      defineTool({
+        name: "regenerate_share_link",
+        description: "Issue a new URL for an agent's share link. The old URL stops working immediately.",
+        scope: "agent",
+        risk: "sensitive",
+        input: { agent_id: import_zod12.z.string().uuid().describe("The agent UUID") },
+        run: (client, { agent_id }) => client.agents.regenerateShareLink(agent_id)
+      })
+    ];
+    var import_agentTools2 = (init_agentTools(), __toCommonJS(agentTools_exports));
+    var REDACTED = "[redacted]";
+    function redactToolSecrets(value) {
+      if (Array.isArray(value)) return value.map(redactToolSecrets);
+      if (!value || typeof value !== "object") return value;
+      const out = {};
+      for (const [k, v] of Object.entries(value)) out[k] = redactToolSecrets(v);
+      const headers = out.tool_id && out.provider_settings?.headers;
+      if (headers && typeof headers === "object" && !Array.isArray(headers)) {
+        out.provider_settings = {
+          ...out.provider_settings,
+          headers: Object.fromEntries(Object.entries(headers).map(([k, v]) => [
+            k,
+            typeof v === "string" && import_agentTools2.API_TOOL_SECRET_REF_PATTERN.test(v) ? v : REDACTED
+          ]))
+        };
+      }
+      return out;
+    }
     var opsToolCatalog2 = [
       ...agentTools,
+      ...agentToolBindingTools,
       ...callTools,
       ...numberTools,
       ...telephonyTools,
@@ -947,8 +1510,9 @@ var require_dist = __commonJS({
       ...dncTools,
       ...webhookTools,
       ...billingTools,
-      ...campaignTools
-    ];
+      ...campaignTools,
+      ...shareLinkTools
+    ].map((t) => ({ ...t, run: async (client, params) => redactToolSecrets(await t.run(client, params)) }));
     var names = /* @__PURE__ */ new Set();
     for (const tool of opsToolCatalog2) {
       if (names.has(tool.name)) throw new Error(`Duplicate ops tool name: ${tool.name}`);
@@ -983,7 +1547,7 @@ function withToolErrors(handler) {
 // package.json
 var package_default = {
   name: "@rymi/mcp",
-  version: "2.0.0",
+  version: "2.1.0",
   description: "Rymi MCP server \u2014 manage AI voice agents via Model Context Protocol",
   license: "MIT",
   author: "Rymi AI <engineering@rymi.live>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rymi/mcp",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Rymi MCP server — manage AI voice agents via Model Context Protocol",
   "license": "MIT",
   "author": "Rymi AI <engineering@rymi.live>",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.11.1",
-    "@rymi/node": "^2.0.0",
+    "@rymi/node": "^2.1.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {