@rymi/mcp 2.8.2 → 2.10.0

package/dist/index.js

@@ -187,6 +187,7 @@ var init_studioCatalog = __esm({
         "llama-4-scout",
         "deepseek-v4-flash",
         "deepseek-v4-pro",
+        "grok-4.7",
         "grok-4-1-fast",
         "grok-3-mini",
         "grok-3-mini-fast",
@@ -250,6 +251,7 @@ var init_studioCatalog = __esm({
       ],
       tts: [
         "aura-2",
+        "flux-tts",
         "gemini-2.5-pro-preview-tts",
         "sonic-3.5",
         "sonic-turbo",
@@ -1837,7 +1839,7 @@ var init_agentConfigSchema = __esm({
       },
       // ── Runtime Timing ──────────────────────────────────────────────────────
       { key: "maxTurnLength", label: "Max Turn Length", description: "Maximum number of conversational turns.", default: 50, type: { kind: "number", min: 1, max: 200 }, apiPath: "advanced.maxTurnLength", section: "advanced", editableIn: "both" },
-      { key: "postSilenceHangup", label: "Post-Silence Hangup", description: "Hang up after this many seconds of silence.", default: 30, type: { kind: "number", min: 1, max: 6e4, unit: "s" }, apiPath: "advanced.postSilenceHangup", section: "advanced", editableIn: "both" },
+      { key: "postSilenceHangup", label: "Post-Silence Hangup", description: "Hang up after this many seconds of silence.", default: 60, type: { kind: "number", min: 1, max: 6e4, unit: "s" }, apiPath: "advanced.postSilenceHangup", section: "advanced", editableIn: "both" },
       { key: "silencePromptMaxCount", label: "Silence Check-ins", description: "How many times the agent checks on a silent caller before the silence goodbye.", default: 2, type: { kind: "number", min: 1, max: 3 }, apiPath: "advanced.silencePromptMaxCount", section: "advanced", editableIn: "both" },
       { key: "silenceHangupMessage", label: "Silence Goodbye", description: "Exact line spoken before a silence hangup. Leave empty to let the agent say a short goodbye in the caller's language.", default: "", type: { kind: "string", maxLength: 200 }, apiPath: "advanced.silenceHangupMessage", section: "advanced", editableIn: "both" },
       { key: "maxCallDuration", label: "Max Call Duration", description: "Hard limit on call length.", default: 600, type: { kind: "number", min: 30, max: 7200, unit: "s" }, apiPath: "advanced.maxCallDuration", section: "advanced", editableIn: "both" },
@@ -2502,6 +2504,7 @@ var init_pricing = __esm({
       "llama-4-scout": 56e-5,
       "deepseek-v4-flash": 34e-5,
       "deepseek-v4-pro": 418e-5,
+      "grok-4.7": 64e-4,
       "grok-4-1-fast": 56e-5,
       "grok-3-mini": 64e-5,
       "grok-3-mini-fast": 48e-5,
@@ -2531,10 +2534,12 @@ var init_pricing = __esm({
       "Qwen/Qwen2.5-72B-Instruct": 22e-4,
       "deepseek-ai/DeepSeek-V3": 14e-4,
       "sarvam-30b": 10526e-8,
-      "sarvam-105b": 77053e-8,
-      "sarvam-105b-conversations": 77053e-8,
+      "sarvam-105b": 0.01024,
+      // measured 2026-10-25, see rates.py
+      "sarvam-105b-conversations": 0.01024,
       // TTS
       "aura-2": 0.027,
+      "flux-tts": 0.0405,
       "gemini-2.5-flash-preview-tts": 0.015,
       "gemini-3.1-flash-tts-preview": 0.015,
       "gpt-4o-mini-tts": 0.015,
@@ -6948,6 +6953,263 @@ var init_supportedCountries = __esm({
   }
 });
 
+// ../shared-types/dist/whatsappTemplates.js
+function hasModelSlot(entry) {
+  if (entry.variables?.some((v) => v.source === "model"))
+    return true;
+  if (entry.buttons?.some((b) => b.source === "model"))
+    return true;
+  return false;
+}
+function valueRuleError(value) {
+  if (typeof value !== "string")
+    return "must be a string";
+  if (value.includes("\n") || value.includes("\r")) {
+    return "must not contain newlines";
+  }
+  if (value.includes("	")) {
+    return "must not contain tabs";
+  }
+  if (/[ ]{5,}/.test(value)) {
+    return "must not contain more than 4 consecutive spaces";
+  }
+  if (value.length > 300) {
+    return `exceeds 300 characters (${value.length})`;
+  }
+  return null;
+}
+function langCode(key) {
+  const k = key.trim().toLowerCase();
+  if (k === "english")
+    return "en";
+  if (k === "hindi")
+    return "hi";
+  return k;
+}
+function resolveLangTag(key) {
+  const k = key.trim().toLowerCase();
+  if (k === "english")
+    return "en";
+  if (k === "hindi")
+    return "hi";
+  if (k === "hinglish")
+    return "hinglish";
+  return k;
+}
+function pickSyncedTemplate(templates, name, languageKey) {
+  if (!templates || !Array.isArray(templates) || templates.length === 0)
+    return null;
+  const matching = templates.filter((t) => t.name === name);
+  if (matching.length === 0)
+    return null;
+  if (matching.length === 1)
+    return matching[0];
+  const target = langCode(languageKey).toLowerCase();
+  const directMatch = matching.find((t) => t.language.toLowerCase().startsWith(target));
+  if (directMatch)
+    return directMatch;
+  if (languageKey.trim().toLowerCase() === "hinglish") {
+    const enFallback = matching.find((t) => t.language.toLowerCase().startsWith("en"));
+    if (enFallback)
+      return enFallback;
+  }
+  return null;
+}
+function templateShapeError(entry, synced) {
+  if (synced.variable_count !== void 0 && synced.variable_count !== null) {
+    const entryVarCount = entry.variables?.length ?? 0;
+    if (entryVarCount !== synced.variable_count) {
+      return `variable count mismatch: entry has ${entryVarCount}, synced template has ${synced.variable_count}`;
+    }
+  }
+  if (synced.buttons !== void 0 && synced.buttons !== null) {
+    const entryButtons = entry.buttons ?? [];
+    const syncedButtons = synced.buttons;
+    if (entryButtons.length !== syncedButtons.length) {
+      return `button count mismatch: entry has ${entryButtons.length}, synced template has ${syncedButtons.length}`;
+    }
+    const syncedByIndex = new Map(syncedButtons.map((b) => [b.index, b]));
+    for (const eb of entryButtons) {
+      const sb = syncedByIndex.get(eb.index);
+      if (!sb) {
+        return `button index ${eb.index} missing in synced template`;
+      }
+      if (eb.type !== sb.type) {
+        return `button index ${eb.index} type mismatch: entry has ${eb.type}, synced template has ${sb.type}`;
+      }
+    }
+  }
+  return null;
+}
+function buildComponents(entry, languageKey, values, buttonValues = {}) {
+  const components = [];
+  const btnVals = buttonValues ?? {};
+  if (values && values.length > 0) {
+    components.push({
+      type: "body",
+      parameters: values.map((text) => ({ type: "text", text }))
+    });
+  }
+  const buttons = entry.buttons ?? [];
+  const sortedButtons = [...buttons].sort((a, b) => a.index - b.index);
+  for (const btn of sortedButtons) {
+    const idxStr = String(btn.index);
+    if (btn.type === "url") {
+      const val = btnVals[btn.index] ?? btnVals[idxStr] ?? btn.value;
+      if (val !== void 0 && val !== null && String(val) !== "") {
+        components.push({
+          type: "button",
+          sub_type: "url",
+          index: idxStr,
+          parameters: [{ type: "text", text: String(val) }]
+        });
+      }
+    } else if (btn.type === "quick_reply") {
+      let payload = btnVals[btn.index] ?? btnVals[idxStr];
+      if (!payload && btn.payload) {
+        payload = btn.payload.replace(/\{lang\}/g, resolveLangTag(languageKey));
+      }
+      if (payload !== void 0 && payload !== null && String(payload) !== "") {
+        components.push({
+          type: "button",
+          sub_type: "quick_reply",
+          index: idxStr,
+          parameters: [{ type: "payload", payload: String(payload) }]
+        });
+      }
+    }
+  }
+  return components;
+}
+function whatsappSenderId(creds, tenantId) {
+  const pnId = creds?.phone_number_id?.trim();
+  if (pnId)
+    return pnId;
+  const src = creds?.src_phone?.trim();
+  if (src)
+    return src;
+  return `simulated:${tenantId || "unknown"}`;
+}
+function isCountryAllowed(phone, allowedCountries) {
+  if (!phone || typeof phone !== "string")
+    return false;
+  const country = phoneNumberCountry(phone);
+  if (!country)
+    return false;
+  const allowed = allowedCountries && allowedCountries.length > 0 ? allowedCountries.map((c) => c.toUpperCase()) : SUPPORTED_COUNTRY_CODES;
+  return allowed.includes(country.toUpperCase());
+}
+function whatsappTemplateBindingErrors(tools) {
+  if (!Array.isArray(tools))
+    return [];
+  const errors = [];
+  for (const tool of tools) {
+    if (!tool || typeof tool !== "object")
+      continue;
+    if (tool.tool_id !== "send_whatsapp_message")
+      continue;
+    const settings = tool.provider_settings;
+    if (!settings || typeof settings !== "object")
+      continue;
+    const templates = settings.templates;
+    if (templates === void 0)
+      continue;
+    if (!Array.isArray(templates)) {
+      errors.push("send_whatsapp_message: provider_settings.templates must be an array");
+      continue;
+    }
+    for (let i = 0; i < templates.length; i++) {
+      const entry = templates[i];
+      const parsed = boundTemplateEntrySchema.safeParse(entry);
+      if (!parsed.success) {
+        const keyName = entry && typeof entry === "object" && entry.key ? String(entry.key) : `index_${i}`;
+        for (const issue of parsed.error.issues) {
+          const pathStr = issue.path.length > 0 ? issue.path.join(".") : "root";
+          errors.push(`send_whatsapp_message template "${keyName}": ${pathStr}: ${issue.message}`);
+        }
+      }
+    }
+  }
+  return errors;
+}
+var import_zod, SUPPORTED_WHATSAPP_COUNTRIES, slotSourceSchema, slotSchema, buttonTypeSchema, buttonSchema, basePolicySchema, boundPolicySchema, baseEntryShape, templateEntrySchema, boundTemplateEntrySchema;
+var init_whatsappTemplates = __esm({
+  "../shared-types/dist/whatsappTemplates.js"() {
+    "use strict";
+    import_zod = require("zod");
+    init_supportedCountries();
+    SUPPORTED_WHATSAPP_COUNTRIES = SUPPORTED_COUNTRY_CODES;
+    slotSourceSchema = import_zod.z.enum([
+      "fixed",
+      "agent_field",
+      "captured",
+      "call",
+      "model"
+    ]);
+    slotSchema = import_zod.z.object({
+      source: slotSourceSchema,
+      path: import_zod.z.string().optional(),
+      value: import_zod.z.string().optional()
+    });
+    buttonTypeSchema = import_zod.z.enum(["url", "quick_reply"]);
+    buttonSchema = import_zod.z.object({
+      index: import_zod.z.number().int().min(0),
+      type: buttonTypeSchema,
+      source: slotSourceSchema.optional(),
+      path: import_zod.z.string().optional(),
+      value: import_zod.z.string().optional(),
+      payload: import_zod.z.string().optional(),
+      reply: import_zod.z.record(import_zod.z.string()).optional()
+    });
+    basePolicySchema = import_zod.z.object({
+      once_per_number: import_zod.z.boolean(),
+      daily_cap: import_zod.z.number().int().min(1).max(3).optional(),
+      allowed_countries: import_zod.z.array(import_zod.z.string()).optional(),
+      max_per_call: import_zod.z.number().int().min(1).optional(),
+      recipient: import_zod.z.enum(["caller_phone", "spoken_confirmed"]).optional(),
+      offer: import_zod.z.enum(["before_goodbye", "on_request"]).optional(),
+      offer_instruction: import_zod.z.string().min(1).optional()
+    });
+    boundPolicySchema = basePolicySchema.extend({
+      max_per_call: import_zod.z.number().int().min(1),
+      recipient: import_zod.z.enum(["caller_phone", "spoken_confirmed"]),
+      offer: import_zod.z.enum(["before_goodbye", "on_request"]),
+      offer_instruction: import_zod.z.string().min(1)
+    });
+    baseEntryShape = {
+      key: import_zod.z.string().min(1),
+      label: import_zod.z.string().min(1),
+      languages: import_zod.z.record(import_zod.z.string().min(1)),
+      variables: import_zod.z.array(slotSchema),
+      buttons: import_zod.z.array(buttonSchema).optional()
+    };
+    templateEntrySchema = import_zod.z.object({
+      ...baseEntryShape,
+      policy: basePolicySchema
+    }).superRefine((data, ctx) => {
+      if (data.key !== "free_form" && hasModelSlot(data)) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          message: "model slot is only allowed on the free_form entry",
+          path: ["variables"]
+        });
+      }
+    });
+    boundTemplateEntrySchema = import_zod.z.object({
+      ...baseEntryShape,
+      policy: boundPolicySchema
+    }).superRefine((data, ctx) => {
+      if (data.key !== "free_form" && hasModelSlot(data)) {
+        ctx.addIssue({
+          code: import_zod.z.ZodIssueCode.custom,
+          message: "model slot is only allowed on the free_form entry",
+          path: ["variables"]
+        });
+      }
+    });
+  }
+});
+
 // ../shared-types/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
@@ -7013,6 +7275,7 @@ __export(dist_exports, {
   STUDIO_SUPPORTED_LANGUAGES: () => STUDIO_SUPPORTED_LANGUAGES,
   SUPPORTED_COUNTRIES: () => SUPPORTED_COUNTRIES,
   SUPPORTED_COUNTRY_CODES: () => SUPPORTED_COUNTRY_CODES,
+  SUPPORTED_WHATSAPP_COUNTRIES: () => SUPPORTED_WHATSAPP_COUNTRIES,
   SYSTEM_VARIABLES: () => SYSTEM_VARIABLES,
   SYSTEM_VARIABLE_KEYS: () => SYSTEM_VARIABLE_KEYS,
   TRACE_ID_HEADER: () => TRACE_ID_HEADER,
@@ -7025,9 +7288,15 @@ __export(dist_exports, {
   applyFlatDiff: () => applyFlatDiff,
   applyWritesToConfig: () => applyWritesToConfig,
   assertE164: () => assertE164,
+  basePolicySchema: () => basePolicySchema,
+  boundPolicySchema: () => boundPolicySchema,
+  boundTemplateEntrySchema: () => boundTemplateEntrySchema,
+  buildComponents: () => buildComponents,
   buildPlans: () => buildPlans,
   buildSystemBusinessValues: () => buildSystemBusinessValues,
   buildTranscriptText: () => buildTranscriptText,
+  buttonSchema: () => buttonSchema,
+  buttonTypeSchema: () => buttonTypeSchema,
   canonicalizeLlmProvider: () => canonicalizeLlmProvider,
   changedFocusedStudioSections: () => changedFocusedStudioSections,
   clarifyableKeys: () => clarifyableKeys,
@@ -7063,6 +7332,7 @@ __export(dist_exports, {
   inferCallerMetadataKey: () => inferCallerMetadataKey2,
   isAgentToolEnabled: () => isAgentToolEnabled,
   isApiKeyScope: () => isApiKeyScope,
+  isCountryAllowed: () => isCountryAllowed,
   isCuratedBusinessType: () => isCuratedBusinessType,
   isDemoDialableCountry: () => isDemoDialableCountry,
   isE164: () => isE164,
@@ -7077,6 +7347,7 @@ __export(dist_exports, {
   isValidTraceId: () => isValidTraceId,
   isVoicemailEndReason: () => isVoicemailEndReason,
   isWithinCallingWindow: () => isWithinCallingWindow,
+  langCode: () => langCode,
   listActiveConnectors: () => listActiveConnectors,
   listContextFields: () => listContextFields,
   mergePostCallConfig: () => mergePostCallConfig,
@@ -7088,10 +7359,12 @@ __export(dist_exports, {
   normalizeVariableAcquisition: () => normalizeVariableAcquisition2,
   phoneNumberCountry: () => phoneNumberCountry,
   phoneNumberIssue: () => phoneNumberIssue,
+  pickSyncedTemplate: () => pickSyncedTemplate,
   pollUntil: () => pollUntil,
   populatedFocusedStudioSections: () => populatedFocusedStudioSections,
   pronunciationSupport: () => pronunciationSupport,
   providerIdsForTool: () => providerIdsForTool,
+  providerRequiresExplicitVoice: () => providerRequiresExplicitVoice,
   publishRequiredKeys: () => publishRequiredKeys,
   readFocusedSectionField: () => readFocusedSectionField,
   readFromPayload: () => readFromPayload,
@@ -7100,6 +7373,7 @@ __export(dist_exports, {
   reinitKeys: () => reinitKeys,
   renderFieldReference: () => renderFieldReference,
   requiredConsentChannels: () => requiredConsentChannels,
+  resolveLangTag: () => resolveLangTag,
   resolveManagedPricePerMin: () => resolveManagedPricePerMin,
   resolveSystemAlias: () => resolveSystemAlias,
   sanitizeTranscriptText: () => sanitizeTranscriptText,
@@ -7107,13 +7381,20 @@ __export(dist_exports, {
   serializeSection: () => serializeSection,
   skuAllowsCountry: () => skuAllowsCountry,
   skuFeaturedInCountry: () => skuFeaturedInCountry,
+  slotSchema: () => slotSchema,
+  slotSourceSchema: () => slotSourceSchema,
   stackCostPerMin: () => stackCostPerMin,
   supportedCountry: () => supportedCountry,
+  templateEntrySchema: () => templateEntrySchema,
+  templateShapeError: () => templateShapeError,
   toSupportedE164: () => toSupportedE164,
   toToolCapabilitySafeView: () => toToolCapabilitySafeView,
   validateAgentTemplate: () => validateAgentTemplate,
   validatePublishConfig: () => validatePublishConfig,
+  valueRuleError: () => valueRuleError,
   variablesFromRequiredSlots: () => variablesFromRequiredSlots2,
+  whatsappSenderId: () => whatsappSenderId,
+  whatsappTemplateBindingErrors: () => whatsappTemplateBindingErrors,
   writeToPayload: () => writeToPayload
 });
 var deriveExtractionFields2, deriveRequiredSlots2, humanizeKey2, inferCallerMetadataKey2, normalizeVariableAcquisition2, normalizeKey2, registerVariable2, variablesFromRequiredSlots2;
@@ -7163,6 +7444,7 @@ var init_dist2 = __esm({
     init_safeUrl();
     init_connectorCatalog();
     init_supportedCountries();
+    init_whatsappTemplates();
     deriveExtractionFields2 = deriveExtractionFields;
     deriveRequiredSlots2 = deriveRequiredSlots;
     humanizeKey2 = humanizeKey;
@@ -7202,6 +7484,7 @@ var require_dist = __commonJS({
       keyAllowsTool: () => keyAllowsTool2,
       opsToolCatalog: () => opsToolCatalog2,
       resolveToolDisposition: () => resolveToolDisposition,
+      toolAnnotations: () => toolAnnotations2,
       withWorkspaceParam: () => withWorkspaceParam2
     });
     module2.exports = __toCommonJS2(index_exports);
@@ -7220,7 +7503,7 @@ var require_dist = __commonJS({
       if (p.scope === "account" && !PRIVILEGED.has(p.role)) return "deny";
       return p.risk === "write" ? "propose" : "confirm";
     }
-    var import_zod = require("zod");
+    var import_zod2 = require("zod");
     var import_shared_types = (init_dist2(), __toCommonJS(dist_exports));
     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 norm2 = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, "");
@@ -7237,32 +7520,32 @@ var require_dist = __commonJS({
       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.'),
-      language: import_zod.z.string().optional().describe('Primary BCP-47 language tag (e.g. "hi-IN", "en-US").'),
-      supported_languages: import_zod.z.array(import_zod.z.string()).optional().describe('All BCP-47 languages the agent should handle, e.g. ["hi-IN","en-US"] for a bilingual agent. The primary `language` is added automatically if omitted here.'),
-      llm_provider: import_zod.z.enum(import_shared_types.AGENT_LLM_PROVIDERS).optional(),
-      llm_model: import_zod.z.string().optional().describe('LLM model id from list_llm_options (e.g. "gemini-2.5-flash", "sarvam-105b").'),
-      llm_fallback_provider: import_zod.z.string().nullable().optional().describe("Fallback LLM provider; null clears it."),
-      llm_fallback_model: import_zod.z.string().nullable().optional().describe("Fallback LLM model; null clears it."),
-      stt_provider: import_zod.z.string().optional().describe('Speech-to-text provider (e.g. "deepgram", "sarvam").'),
-      stt_model: import_zod.z.string().optional(),
-      stt_fallback_provider: import_zod.z.string().nullable().optional(),
-      stt_fallback_model: import_zod.z.string().nullable().optional(),
-      tts_provider: import_zod.z.string().optional().describe('Text-to-speech provider (e.g. "elevenlabs", "sarvam", "cartesia").'),
-      tts_model: import_zod.z.string().optional(),
-      tts_fallback_provider: import_zod.z.string().nullable().optional(),
-      tts_fallback_model: import_zod.z.string().nullable().optional(),
-      custom_llm_url: import_zod.z.string().nullable().optional().describe("Self-hosted LLM endpoint (https:// or wss://). Enterprise only; null clears."),
-      custom_voice_url: import_zod.z.string().nullable().optional().describe("Self-hosted TTS endpoint (https:// or wss://). Enterprise only; null clears."),
-      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. 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(),
-      post_call: import_zod.z.record(import_zod.z.any()).optional()
+      system_prompt: import_zod2.z.string().optional().describe("Full system prompt for the agent. If given without persona/playbook, the server auto-structures it."),
+      voice: import_zod2.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.'),
+      language: import_zod2.z.string().optional().describe('Primary BCP-47 language tag (e.g. "hi-IN", "en-US"). For managed agents, must belong to the SKU\u2019s supported_languages.'),
+      supported_languages: import_zod2.z.array(import_zod2.z.string()).optional().describe('All BCP-47 languages the agent should handle, e.g. ["hi-IN","en-US"] for a bilingual custom agent. Fixed to [language] by the plan for managed agents.'),
+      llm_provider: import_zod2.z.enum(import_shared_types.AGENT_LLM_PROVIDERS).optional().describe("LLM provider (custom agents only; fixed by the plan for managed agents)."),
+      llm_model: import_zod2.z.string().optional().describe('LLM model id from list_llm_options (e.g. "gemini-2.5-flash", "sarvam-105b"). Fixed by the plan for managed agents.'),
+      llm_fallback_provider: import_zod2.z.string().nullable().optional().describe("Fallback LLM provider; null clears it. Fixed by the plan for managed agents."),
+      llm_fallback_model: import_zod2.z.string().nullable().optional().describe("Fallback LLM model; null clears it. Fixed by the plan for managed agents."),
+      stt_provider: import_zod2.z.string().optional().describe('Speech-to-text provider (e.g. "deepgram", "sarvam"). Fixed by the plan for managed agents.'),
+      stt_model: import_zod2.z.string().optional().describe("Speech-to-text model id. Fixed by the plan for managed agents."),
+      stt_fallback_provider: import_zod2.z.string().nullable().optional().describe("Fallback STT provider. Fixed by the plan for managed agents."),
+      stt_fallback_model: import_zod2.z.string().nullable().optional().describe("Fallback STT model. Fixed by the plan for managed agents."),
+      tts_provider: import_zod2.z.string().optional().describe('Text-to-speech provider (e.g. "elevenlabs", "sarvam", "cartesia"). Fixed by the plan for managed agents.'),
+      tts_model: import_zod2.z.string().optional().describe("Text-to-speech model id. Fixed by the plan for managed agents."),
+      tts_fallback_provider: import_zod2.z.string().nullable().optional().describe("Fallback TTS provider. Fixed by the plan for managed agents."),
+      tts_fallback_model: import_zod2.z.string().nullable().optional().describe("Fallback TTS model. Fixed by the plan for managed agents."),
+      custom_llm_url: import_zod2.z.string().nullable().optional().describe("Self-hosted LLM endpoint (https:// or wss://). Enterprise only; null clears."),
+      custom_voice_url: import_zod2.z.string().nullable().optional().describe("Self-hosted TTS endpoint (https:// or wss://). Enterprise only; null clears."),
+      custom_voice_mode: import_zod2.z.enum(["rymi", "openai-compat"]).optional().describe("Wire format for custom_voice_url."),
+      custom_transcriber_url: import_zod2.z.string().nullable().optional().describe("Self-hosted STT endpoint (https:// or wss://). Enterprise only; null clears."),
+      prompt_mode: import_zod2.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_zod2.z.record(import_zod2.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_zod2.z.record(import_zod2.z.any()).optional().describe("Playbook configuration object"),
+      advanced: import_zod2.z.record(import_zod2.z.any()).optional(),
+      features: import_zod2.z.record(import_zod2.z.any()).optional(),
+      post_call: import_zod2.z.record(import_zod2.z.any()).optional()
     };
     function foldPromptMode(params) {
       const { prompt_mode, ...rest } = params;
@@ -7299,8 +7582,8 @@ var require_dist = __commonJS({
         routes: ["GET /v1/agents"],
         keyScopes: ["agents:read"],
         input: {
-          limit: import_zod.z.number().int().min(1).max(500).optional().describe("Max agents to return (default 50)"),
-          offset: import_zod.z.number().int().min(0).optional().describe("Pagination offset")
+          limit: import_zod2.z.number().int().min(1).max(500).optional().describe("Max agents to return (default 50)"),
+          offset: import_zod2.z.number().int().min(0).optional().describe("Pagination offset")
         },
         run: (client, { limit, offset }) => client.agents.list({ limit, offset })
       }),
@@ -7311,7 +7594,7 @@ var require_dist = __commonJS({
         risk: "read",
         routes: ["GET /v1/agents/:id"],
         keyScopes: ["agents:read"],
-        input: { agent_id: import_zod.z.string().uuid().describe("The agent UUID") },
+        input: { agent_id: import_zod2.z.string().uuid().describe("The agent UUID") },
         run: (client, { agent_id }) => client.agents.retrieve(agent_id)
       }),
       defineTool({
@@ -7332,8 +7615,8 @@ var require_dist = __commonJS({
         routes: ["GET /v1/agents/llm-options"],
         keyScopes: ["agents:read"],
         input: {
-          provider: import_zod.z.string().optional().describe('Filter to one voice provider, e.g. "elevenlabs", "sarvam", "gemini", "cartesia", "deepgram".'),
-          model_id: import_zod.z.string().optional().describe("Filter to voices compatible with a given model id (matched against the voice's supported_model_ids).")
+          provider: import_zod2.z.string().optional().describe('Filter to one voice provider, e.g. "elevenlabs", "sarvam", "gemini", "cartesia", "deepgram".'),
+          model_id: import_zod2.z.string().optional().describe("Filter to voices compatible with a given model id (matched against the voice's supported_model_ids).")
         },
         run: async (client, { provider, model_id }) => {
           const { voices } = await client.agents.llmOptions();
@@ -7366,9 +7649,9 @@ var require_dist = __commonJS({
         routes: ["POST /v1/agents/stack-preview"],
         keyScopes: ["agents:write"],
         input: {
-          supported_languages: import_zod.z.array(import_zod.z.string()).min(1).describe('BCP-47 languages to resolve a stack for, e.g. ["hi-IN","en-US"].'),
-          language: import_zod.z.string().optional().describe("Primary BCP-47 language (defaults to the first supported language)."),
-          current_provider_config: import_zod.z.record(import_zod.z.any()).optional().describe("Existing provider_config to diff against, if any.")
+          supported_languages: import_zod2.z.array(import_zod2.z.string()).min(1).describe('BCP-47 languages to resolve a stack for, e.g. ["hi-IN","en-US"].'),
+          language: import_zod2.z.string().optional().describe("Primary BCP-47 language (defaults to the first supported language)."),
+          current_provider_config: import_zod2.z.record(import_zod2.z.any()).optional().describe("Existing provider_config to diff against, if any.")
         },
         run: (client, params) => client.agents.previewStack(params)
       }),
@@ -7380,10 +7663,10 @@ var require_dist = __commonJS({
         routes: ["GET /v1/agents/:id/calls"],
         keyScopes: ["agents:read"],
         input: {
-          agent_id: import_zod.z.string().uuid(),
-          limit: import_zod.z.number().int().min(1).max(200).optional(),
-          offset: import_zod.z.number().int().min(0).optional(),
-          status: import_zod.z.string().optional().describe("Filter by call status")
+          agent_id: import_zod2.z.string().uuid(),
+          limit: import_zod2.z.number().int().min(1).max(200).optional(),
+          offset: import_zod2.z.number().int().min(0).optional(),
+          status: import_zod2.z.string().optional().describe("Filter by call status")
         },
         run: (client, { agent_id, ...params }) => client.agents.listCalls(agent_id, params)
       }),
@@ -7395,11 +7678,11 @@ var require_dist = __commonJS({
         routes: ["POST /v1/agents/validate-publish"],
         keyScopes: ["agents:write"],
         input: {
-          agent_id: import_zod.z.string().uuid().optional().describe("Merge validation with a persisted agent"),
-          name: import_zod.z.string().optional(),
-          voice: import_zod.z.string().optional(),
-          persona: import_zod.z.record(import_zod.z.any()).optional(),
-          playbook: import_zod.z.record(import_zod.z.any()).optional()
+          agent_id: import_zod2.z.string().uuid().optional().describe("Merge validation with a persisted agent"),
+          name: import_zod2.z.string().optional(),
+          voice: import_zod2.z.string().optional(),
+          persona: import_zod2.z.record(import_zod2.z.any()).optional(),
+          playbook: import_zod2.z.record(import_zod2.z.any()).optional()
         },
         run: (client, params) => client.agents.validatePublish(params)
       }),
@@ -7411,10 +7694,10 @@ var require_dist = __commonJS({
         routes: ["GET /v1/agents/:id", "POST /v1/agents/apply-changes"],
         keyScopes: ["agents:read", "agents:write"],
         input: {
-          agent_id: import_zod.z.string().uuid().describe("Agent to load currentConfig from (recommended)"),
-          changes: import_zod.z.array(import_zod.z.object({ key: import_zod.z.string(), value: import_zod.z.any() })).describe("Array of {key, value} field changes"),
-          mode: import_zod.z.enum(["create", "edit"]).describe("create = new agent, edit = updating existing"),
-          lenient: import_zod.z.boolean().optional().describe("Skip unknown-field hard-fail (not recommended)")
+          agent_id: import_zod2.z.string().uuid().describe("Agent to load currentConfig from (recommended)"),
+          changes: import_zod2.z.array(import_zod2.z.object({ key: import_zod2.z.string(), value: import_zod2.z.any() })).describe("Array of {key, value} field changes"),
+          mode: import_zod2.z.enum(["create", "edit"]).describe("create = new agent, edit = updating existing"),
+          lenient: import_zod2.z.boolean().optional().describe("Skip unknown-field hard-fail (not recommended)")
         },
         run: async (client, { agent_id, changes, mode, lenient }) => {
           const current = await client.agents.retrieve(agent_id);
@@ -7435,8 +7718,8 @@ var require_dist = __commonJS({
         routes: ["POST /v1/agents/enrich-company"],
         keyScopes: ["agents:write"],
         input: {
-          company_name: import_zod.z.string().min(1),
-          website_url: import_zod.z.string().url()
+          company_name: import_zod2.z.string().min(1),
+          website_url: import_zod2.z.string().url()
         },
         run: (client, { company_name, website_url }) => client.agents.enrichCompany({ companyName: company_name, websiteUrl: website_url })
       }),
@@ -7448,10 +7731,10 @@ var require_dist = __commonJS({
         routes: ["POST /v1/agents/generate"],
         keyScopes: ["agents:write"],
         input: {
-          prompt: import_zod.z.string().min(1).describe("Description of the agent you want to create"),
-          mode: import_zod.z.enum(["create", "edit"]).optional().default("create"),
-          current_config: import_zod.z.record(import_zod.z.any()).optional().describe("Existing config when editing"),
-          options: import_zod.z.record(import_zod.z.any()).optional().describe("Override hints e.g. {voice, llm_provider}")
+          prompt: import_zod2.z.string().min(1).describe("Description of the agent you want to create"),
+          mode: import_zod2.z.enum(["create", "edit"]).optional().default("create"),
+          current_config: import_zod2.z.record(import_zod2.z.any()).optional().describe("Existing config when editing"),
+          options: import_zod2.z.record(import_zod2.z.any()).optional().describe("Override hints e.g. {voice, llm_provider}")
         },
         run: (client, params) => client.agents.generate({ prompt: params.prompt, options: params.options })
       }),
@@ -7463,7 +7746,7 @@ var require_dist = __commonJS({
         routes: ["POST /v1/agents"],
         keyScopes: ["agents:write"],
         input: {
-          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."),
+          name: import_zod2.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(normalizeLlmProvider(foldPromptMode(params)))
@@ -7476,10 +7759,10 @@ var require_dist = __commonJS({
         routes: ["GET /v1/agents", "PUT /v1/agents/:id"],
         keyScopes: ["agents:read", "agents:write"],
         input: {
-          agent_id: import_zod.z.string().uuid().describe("The agent UUID to update"),
-          name: import_zod.z.string().optional().describe("Studio label (sidebar/agent list only). To change the spoken name, set persona.name."),
+          agent_id: import_zod2.z.string().uuid().describe("The agent UUID to update"),
+          name: import_zod2.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()
+          chat_summary: import_zod2.z.string().nullable().optional()
         },
         run: async (client, { agent_id, ...params }) => client.agents.update(await resolveAgentId(client, agent_id), normalizeLlmProvider(foldPromptMode(params)))
       }),
@@ -7490,7 +7773,7 @@ var require_dist = __commonJS({
         risk: "sensitive",
         routes: ["GET /v1/agents", "DELETE /v1/agents/:id"],
         keyScopes: ["agents:read", "agents:write"],
-        input: { agent_id: import_zod.z.string().uuid().describe("The agent UUID to delete") },
+        input: { agent_id: import_zod2.z.string().uuid().describe("The agent UUID to delete") },
         run: async (client, { agent_id }) => client.agents.delete(await resolveAgentId(client, agent_id))
       }),
       defineTool({
@@ -7500,11 +7783,11 @@ var require_dist = __commonJS({
         risk: "write",
         routes: ["GET /v1/agents", "POST /v1/agents/:id/clone"],
         keyScopes: ["agents:read", "agents:write"],
-        input: { agent_id: import_zod.z.string().uuid().describe("The agent UUID to clone") },
+        input: { agent_id: import_zod2.z.string().uuid().describe("The agent UUID to clone") },
         run: async (client, { agent_id }) => client.agents.clone(await resolveAgentId(client, agent_id))
       })
     ];
-    var import_zod2 = require("zod");
+    var import_zod22 = require("zod");
     var callTools = [
       defineTool({
         name: "list_calls",
@@ -7514,10 +7797,10 @@ var require_dist = __commonJS({
         routes: ["GET /v1/calls"],
         keyScopes: ["calls:read"],
         input: {
-          limit: import_zod2.z.number().int().min(1).max(200).optional().describe("Max calls to return"),
-          offset: import_zod2.z.number().int().min(0).optional().describe("Pagination offset"),
-          cursor: import_zod2.z.string().optional().describe("Opaque cursor for keyset pagination"),
-          status: import_zod2.z.string().optional().describe("Filter by call status (e.g. completed, in_progress, failed)")
+          limit: import_zod22.z.number().int().min(1).max(200).optional().describe("Max calls to return"),
+          offset: import_zod22.z.number().int().min(0).optional().describe("Pagination offset"),
+          cursor: import_zod22.z.string().optional().describe("Opaque cursor for keyset pagination"),
+          status: import_zod22.z.string().optional().describe("Filter by call status (e.g. completed, in_progress, failed)")
         },
         run: (client, params) => client.calls.list(params)
       }),
@@ -7529,8 +7812,8 @@ var require_dist = __commonJS({
         routes: ["GET /v1/calls/active"],
         keyScopes: ["calls:read"],
         input: {
-          limit: import_zod2.z.number().int().min(1).max(200).optional(),
-          offset: import_zod2.z.number().int().min(0).optional()
+          limit: import_zod22.z.number().int().min(1).max(200).optional(),
+          offset: import_zod22.z.number().int().min(0).optional()
         },
         run: (client, params) => client.calls.active(params)
       }),
@@ -7541,7 +7824,7 @@ var require_dist = __commonJS({
         risk: "read",
         routes: ["GET /v1/calls/:id"],
         keyScopes: ["calls:read"],
-        input: { call_id: import_zod2.z.string().describe("The call ID") },
+        input: { call_id: import_zod22.z.string().describe("The call ID") },
         run: (client, { call_id }) => client.calls.retrieve(call_id)
       }),
       defineTool({
@@ -7551,7 +7834,7 @@ var require_dist = __commonJS({
         risk: "read",
         routes: ["GET /v1/calls/:id/summary"],
         keyScopes: ["calls:read"],
-        input: { call_id: import_zod2.z.string().describe("The call ID") },
+        input: { call_id: import_zod22.z.string().describe("The call ID") },
         run: (client, { call_id }) => client.calls.summary(call_id)
       }),
       defineTool({
@@ -7561,7 +7844,7 @@ var require_dist = __commonJS({
         risk: "read",
         routes: ["GET /v1/calls/:id/transcript"],
         keyScopes: ["calls:read"],
-        input: { call_id: import_zod2.z.string().describe("The call ID") },
+        input: { call_id: import_zod22.z.string().describe("The call ID") },
         run: (client, { call_id }) => client.calls.transcript(call_id)
       }),
       defineTool({
@@ -7571,7 +7854,7 @@ var require_dist = __commonJS({
         risk: "read",
         routes: ["GET /v1/calls/:id/recording"],
         keyScopes: ["calls:read"],
-        input: { call_id: import_zod2.z.string().describe("The call ID") },
+        input: { call_id: import_zod22.z.string().describe("The call ID") },
         run: (client, { call_id }) => client.calls.recording(call_id)
       }),
       defineTool({
@@ -7591,29 +7874,41 @@ var require_dist = __commonJS({
         risk: "write",
         routes: ["POST /v1/calls/:id/reprocess"],
         keyScopes: ["calls:write"],
-        input: { call_id: import_zod2.z.string().describe("The call ID to reprocess") },
+        input: { call_id: import_zod22.z.string().describe("The call ID to reprocess") },
         run: (client, { call_id }) => client.calls.reprocess(call_id)
       }),
       defineTool({
         name: "create_call",
-        description: "WARNING: places a real, billable PSTN call. `from_number` is the caller ID shown to the recipient and must be a phone number registered to your account \u2014 omit it to use the agent's attached number. `identity` is the destination in strict E.164 (e.g. +15555550123).",
+        description: "WARNING: places a real, billable PSTN call. `from_number` is the caller ID shown to the recipient and must be a phone number registered to your account \u2014 omit it to use the agent's attached number. `identity` is the destination in strict E.164 (e.g. +15555550123). Set `test` true to mark the call as a test and dial from the shared test number (no from_number; the destination must be a confirmed number).",
         scope: "agent",
         risk: "sensitive",
         routes: ["POST /v1/calls"],
         keyScopes: ["calls:write"],
         input: {
-          agent_id: import_zod2.z.string().uuid().describe("The agent that will handle the call"),
-          participants: import_zod2.z.array(import_zod2.z.object({
-            transport: import_zod2.z.enum(["webrtc", "pstn"]),
-            identity: import_zod2.z.string().describe("Destination phone number (pstn) or participant identity (webrtc)"),
-            from_number: import_zod2.z.string().optional().describe("Caller ID / from number for pstn"),
-            metadata: import_zod2.z.record(import_zod2.z.any()).optional()
+          agent_id: import_zod22.z.string().uuid().describe("The agent that will handle the call"),
+          participants: import_zod22.z.array(import_zod22.z.object({
+            transport: import_zod22.z.enum(["webrtc", "pstn"]),
+            identity: import_zod22.z.string().describe("Destination phone number (pstn) or participant identity (webrtc)"),
+            from_number: import_zod22.z.string().optional().describe("Caller ID / from number for pstn"),
+            metadata: import_zod22.z.record(import_zod22.z.any()).optional()
           })).min(1),
-          metadata: import_zod2.z.record(import_zod2.z.any()).optional(),
-          variables: import_zod2.z.record(import_zod2.z.any()).optional().describe("Playbook variables to seed the call"),
-          post_call: import_zod2.z.record(import_zod2.z.any()).optional()
+          metadata: import_zod22.z.record(import_zod22.z.any()).optional(),
+          variables: import_zod22.z.record(import_zod22.z.any()).optional().describe("Playbook variables to seed the call"),
+          post_call: import_zod22.z.record(import_zod22.z.any()).optional(),
+          test: import_zod22.z.boolean().optional().describe("Mark the call as a test and use the shared test number. Do not also set from_number.")
         },
-        run: (client, params) => client.calls.create(params)
+        run: (client, params) => {
+          const { test, metadata, ...rest } = params;
+          if (test) {
+            return client.calls.create({
+              ...rest,
+              test: true,
+              use_test_pool: true,
+              metadata: { ...metadata || {}, source: "mcp_test" }
+            });
+          }
+          return client.calls.create({ ...rest, ...metadata ? { metadata } : {} });
+        }
       }),
       defineTool({
         name: "batch_call",
@@ -7623,18 +7918,18 @@ var require_dist = __commonJS({
         routes: ["POST /v1/calls/batch"],
         keyScopes: ["calls:write"],
         input: {
-          agent_id: import_zod2.z.string().uuid().describe("The agent that will handle the calls"),
-          to: import_zod2.z.array(import_zod2.z.string()).optional().describe("Simple list of destination phone numbers"),
-          recipients: import_zod2.z.array(import_zod2.z.object({
-            to: import_zod2.z.string().optional(),
-            from_number: import_zod2.z.string().optional(),
-            metadata: import_zod2.z.record(import_zod2.z.any()).optional()
+          agent_id: import_zod22.z.string().uuid().describe("The agent that will handle the calls"),
+          to: import_zod22.z.array(import_zod22.z.string()).optional().describe("Simple list of destination phone numbers"),
+          recipients: import_zod22.z.array(import_zod22.z.object({
+            to: import_zod22.z.string().optional(),
+            from_number: import_zod22.z.string().optional(),
+            metadata: import_zod22.z.record(import_zod22.z.any()).optional()
           })).optional().describe("Per-recipient targets with optional from_number/metadata"),
-          from_number: import_zod2.z.string().optional().describe("Default caller ID / from number"),
-          batch_id: import_zod2.z.string().optional(),
-          metadata: import_zod2.z.record(import_zod2.z.any()).optional(),
-          variables: import_zod2.z.record(import_zod2.z.any()).optional(),
-          post_call: import_zod2.z.record(import_zod2.z.any()).optional()
+          from_number: import_zod22.z.string().optional().describe("Default caller ID / from number"),
+          batch_id: import_zod22.z.string().optional(),
+          metadata: import_zod22.z.record(import_zod22.z.any()).optional(),
+          variables: import_zod22.z.record(import_zod22.z.any()).optional(),
+          post_call: import_zod22.z.record(import_zod22.z.any()).optional()
         },
         run: (client, params) => client.calls.batch(params)
       }),
@@ -7645,7 +7940,7 @@ var require_dist = __commonJS({
         risk: "sensitive",
         routes: ["POST /v1/calls/:id/end"],
         keyScopes: ["calls:write"],
-        input: { call_id: import_zod2.z.string().describe("The call ID to end") },
+        input: { call_id: import_zod22.z.string().describe("The call ID to end") },
         run: (client, { call_id }) => client.calls.end(call_id)
       }),
       defineTool({
@@ -7656,12 +7951,12 @@ var require_dist = __commonJS({
         routes: ["POST /v1/calls/:id/participants"],
         keyScopes: ["calls:write"],
         input: {
-          call_id: import_zod2.z.string().describe("The in-progress call ID"),
-          participants: import_zod2.z.array(import_zod2.z.object({
-            transport: import_zod2.z.enum(["webrtc", "pstn"]),
-            identity: import_zod2.z.string().describe("Destination phone number (pstn, E.164) or participant identity (webrtc)"),
-            from_number: import_zod2.z.string().optional().describe("Caller ID for pstn"),
-            metadata: import_zod2.z.record(import_zod2.z.any()).optional()
+          call_id: import_zod22.z.string().describe("The in-progress call ID"),
+          participants: import_zod22.z.array(import_zod22.z.object({
+            transport: import_zod22.z.enum(["webrtc", "pstn"]),
+            identity: import_zod22.z.string().describe("Destination phone number (pstn, E.164) or participant identity (webrtc)"),
+            from_number: import_zod22.z.string().optional().describe("Caller ID for pstn"),
+            metadata: import_zod22.z.record(import_zod22.z.any()).optional()
           })).min(1)
         },
         run: (client, { call_id, participants }) => client.calls.addParticipants(call_id, { participants })
@@ -8982,6 +9277,39 @@ var require_dist = __commonJS({
         }
       };
     }
+    var DESTRUCTIVE_NAMES = /* @__PURE__ */ new Set([
+      "end_call",
+      "undo_agent_change",
+      "regenerate_share_link",
+      "rotate_campaign_intake",
+      // Overwrite or drop stored config through a PUT, so no DELETE route gives them away.
+      "remove_agent_tool",
+      "set_agent_tools",
+      "set_tool_secret"
+    ]);
+    var IDEMPOTENT_NAMES = /* @__PURE__ */ new Set(["end_call", "pause_campaign"]);
+    var NOT_IDEMPOTENT_NAMES = /* @__PURE__ */ new Set(["add_agent_tool"]);
+    function isIdempotent(tool) {
+      if (IDEMPOTENT_NAMES.has(tool.name)) return true;
+      if (NOT_IDEMPOTENT_NAMES.has(tool.name)) return false;
+      const writes = tool.routes.filter((r) => !r.startsWith("GET "));
+      return writes.length > 0 && writes.every((r) => /^(PUT|PATCH|DELETE) /.test(r));
+    }
+    var ACRONYMS = { dnc: "DNC", llm: "LLM" };
+    function titleOf(name) {
+      const words = name.split("_").map((w) => ACRONYMS[w] ?? w);
+      return words.join(" ").replace(/^./, (c) => c.toUpperCase());
+    }
+    function toolAnnotations2(tool) {
+      const readOnly = tool.risk === "read";
+      return {
+        title: titleOf(tool.name),
+        readOnlyHint: readOnly,
+        destructiveHint: !readOnly && (DESTRUCTIVE_NAMES.has(tool.name) || tool.routes.some((r) => r.startsWith("DELETE "))),
+        idempotentHint: readOnly || isIdempotent(tool),
+        openWorldHint: !readOnly
+      };
+    }
   }
 });
 
@@ -9011,7 +9339,8 @@ function withToolErrors(handler) {
 // package.json
 var package_default = {
   name: "@rymi/mcp",
-  version: "2.8.2",
+  mcpName: "io.github.rymi-live/rymi-mcp",
+  version: "2.10.0",
   description: "Rymi MCP server \u2014 manage AI voice agents via Model Context Protocol",
   license: "MIT",
   author: "Rymi AI <engineering@rymi.live>",
@@ -9107,6 +9436,7 @@ async function createServer(apiKey2, options = {}) {
       tool.name,
       tool.description,
       tool.input,
+      (0, import_ops_tools.toolAnnotations)(tool),
       withToolErrors(async (params) => {
         const result2 = await tool.run(rymi, params);
         return { content: [{ type: "text", text: JSON.stringify(result2, null, 2) }] };

package/package.json

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