mcp-scraper 0.67.0 → 0.68.0

package/dist/{chunk-GT63KEUB.js → chunk-TV76V5OO.js}

@@ -1,5 +1,5 @@
 // src/version.ts
-var PACKAGE_VERSION = "0.67.0";
+var PACKAGE_VERSION = "0.68.0";
 
 export {
   PACKAGE_VERSION

package/dist/{chunk-XOOKZYZG.js → chunk-V6H7NGSV.js}

@@ -25,7 +25,7 @@ import {
 } from "./chunk-VXLU74YZ.js";
 import {
   PACKAGE_VERSION
-} from "./chunk-GT63KEUB.js";
+} from "./chunk-TV76V5OO.js";
 import {
   createPrivateArtifact,
   privateArtifactOwnerId,
@@ -38,7 +38,7 @@ import {
   PAA_QUESTION_CREDITS,
   PAGE_SCRAPE_CREDITS,
   SERP_SEARCH_CREDITS
-} from "./chunk-AYJHI2FK.js";
+} from "./chunk-WNL42AMC.js";
 import {
   PUBLIC_ERROR_CODES,
   buildPublicErrorEnvelope,
@@ -769,6 +769,7 @@ var FIELD_DESCRIPTIONS = {
   artifactSelection: "Explicit HTML artifact choice; omit to preserve the current selection.",
   assetId: "Opaque image asset identifier returned by an image asset tool.",
   attributionModel: "Attribution model applied to the report; defaults to first touch.",
+  answered: "Optional call-answer state required for this conversion rule to match.",
   authoringInstructions: "Presentation guidance for authors using this saved template; executable prompts or code are rejected.",
   baseRevision: "Last revision read by the caller; supply it to reject an update if the record changed meanwhile.",
   brand: "Validated visual-brand settings applied to the generated form.",
@@ -783,6 +784,7 @@ var FIELD_DESCRIPTIONS = {
   consentText: "Optional consent disclosure displayed with the form submission control.",
   content: "Complete content to route, validate, or store; do not substitute a partial excerpt when full content is required.",
   conversionKind: "Optional normalized conversion event kind filter.",
+  condition: "Declarative event conditions that must match before X-Ray creates a conversion.",
   countryCode: "Two-letter country code used to filter analytics rows.",
   createdAfter: "Inclusive ISO 8601 lower bound for asset creation time.",
   createdBefore: "Exclusive ISO 8601 upper bound for asset creation time.",
@@ -795,8 +797,37 @@ var FIELD_DESCRIPTIONS = {
   deviceClass: "Optional normalized device-class filter.",
   dimension: "Dimension used to group returned analytics rows.",
   eventName: "Optional normalized analytics event-name filter.",
+  eventId: "Caller-owned canonical event identifier used for end-to-end deduplication.",
+  eventKind: "Canonical event family used for journey storage and conversion-rule evaluation.",
+  occurredAt: "ISO 8601 timestamp when the source event actually occurred.",
+  sourceEventId: "Stable identifier assigned by the source system for idempotent ingestion.",
+  sourceAccountRef: "Stable non-secret account identifier at the phone, CRM, or event source.",
+  serviceConnectionRef: "Optional MCP Scraper connected-service identifier used for governed provider actions.",
+  webhookSecret: "Provider webhook validation secret; it is encrypted at rest and never returned.",
+  provider: "Supported phone, CRM, or advertising provider for this governed connection.",
+  personId: "Opaque X-Ray person identifier returned by an attributed-people or journey result.",
+  visitorId: "Consented first-party visitor identifier used for deterministic journey linking.",
+  sessionId: "First-party session identifier used for deterministic journey linking.",
+  personRef: "Opaque source-system person reference; do not place raw contact data here.",
+  callId: "Stable call identifier assigned by the phone provider.",
+  dealId: "Stable CRM deal or opportunity identifier.",
+  orderId: "Stable order identifier used for conversion deduplication and reconciliation.",
+  stageId: "Exact CRM stage identifier required for the conversion rule to match.",
+  minimumCallDurationSeconds: "Minimum connected call duration required for the conversion rule to match.",
+  excludedTags: "Event tags that prevent this conversion rule from matching, such as spam.",
+  requiredTags: "Event tags that must all be present before this conversion rule matches.",
+  defaultValueMinor: "Optional default conversion value in the currency minor unit.",
+  defaultCurrency: "Three-letter default currency code used when a matched event has no value currency.",
+  enabled: "Whether the new rule should begin evaluating events immediately.",
+  schemaVersion: "Canonical X-Ray event schema version; use version 1.",
+  canonicalUrl: "Canonical public page URL associated with the event.",
+  sourceName: "Normalized acquisition-source name associated with the event.",
+  valueMinor: "Monetary event value in the smallest unit of the supplied currency.",
+  currency: "Three-letter ISO currency code for the event value.",
+  clickIds: "Native advertising click identifiers preserved for deterministic offline conversion matching.",
+  properties: "Bounded non-secret event properties used for reporting and declarative rule evaluation.",
   expiresInDays: "Requested view-link lifetime in days; the server enforces its maximum.",
-  externalDatasetId: "Optional provider dataset identifier already owned by the connected account.",
+  externalDatasetId: "Provider destination identifier already owned by the connected account.",
   fields: "Ordered form-field definitions to render and validate for submissions.",
   filename: "Original CSV filename retained for the import receipt; this is not a local path.",
   folder: "Optional governed folder override inside the selected vault.",
@@ -804,6 +835,17 @@ var FIELD_DESCRIPTIONS = {
   format: "Artifact serialization format to generate.",
   from: "Inclusive ISO 8601 lower time bound.",
   fromVault: "Vault containing the starting memory note; omit only when the note reference already resolves unambiguously.",
+  gclid: "Google Click ID captured from the attributed landing URL.",
+  gbraid: "Google app-to-web click identifier captured from the attributed landing URL.",
+  wbraid: "Google web-to-app click identifier captured from the attributed landing URL.",
+  fbclid: "Meta click identifier captured from the attributed landing URL.",
+  fbp: "Meta first-party browser identifier captured with consent.",
+  fbc: "Meta click cookie value captured or derived from fbclid with consent.",
+  ttclid: "TikTok click identifier captured from the attributed landing URL.",
+  rdt_cid: "Reddit click identifier captured from the attributed landing URL.",
+  msclkid: "Microsoft Advertising click identifier captured from the attributed landing URL.",
+  li_fat_id: "LinkedIn first-party attribution identifier captured from the landing URL.",
+  snapclid: "Snapchat click identifier captured from the attributed landing URL.",
   idempotencyKey: "Caller-owned opaque key for this intended operation; reuse only when retrying the same operation.",
   includePreview: "When true, mint a short-lived authorized preview URL with the metadata result.",
   limit: "Maximum rows or records to return on this page; use the returned cursor for more.",
@@ -843,6 +885,10 @@ var FIELD_DESCRIPTIONS = {
   sourceKind: "Provenance category used to filter or label governed image assets.",
   sourceRef: "Original source URL or opaque artifact reference preserved as image provenance.",
   sourceSystem: "CRM system represented by the uploaded CSV.",
+  triggerKind: "Browser trigger family: a page path, delegated element click, or delegated form submission.",
+  pathMatch: "Whether the page trigger matches the exact path or every path beneath the supplied prefix.",
+  selector: "Safe CSS selector used only to recognize a clicked element or submitted form; no DOM content is captured.",
+  oncePerSession: "When true, emit this named browser event at most once in the current browser session.",
   state: "Two-letter US state for the Local Sourcebook listing market.",
   status: "Lifecycle status used to filter or update the selected records.",
   submitLabel: "Optional text displayed on the form submission button.",
@@ -10897,8 +10943,145 @@ var AnalyticsCreateActivationInputSchema = {
   siteId: z8.string().uuid(),
   platform: z8.enum(["meta", "google", "tiktok", "reddit"]),
   name: z8.string().min(1).max(120),
-  connectionRef: z8.string().max(240).optional(),
-  externalDatasetId: z8.string().max(240).optional()
+  connectionRef: z8.string().trim().min(1).max(240),
+  externalDatasetId: z8.string().trim().min(1).max(240)
+};
+var AnalyticsCreateConnectionInputSchema = {
+  siteId: z8.string().uuid(),
+  provider: z8.enum(["callrail", "calltrackingmetrics", "twilio", "hubspot", "highlevel", "generic_crm"]),
+  name: z8.string().min(1).max(120),
+  sourceAccountRef: z8.string().min(1).max(240),
+  serviceConnectionRef: z8.string().max(240).optional(),
+  webhookSecret: z8.string().min(8).max(1e3).optional(),
+  config: z8.record(z8.string(), z8.unknown()).optional()
+};
+var AnalyticsCreateRuleInputSchema = {
+  siteId: z8.string().uuid(),
+  name: z8.string().min(1).max(120),
+  conversionKind: z8.string().regex(/^[a-z][a-z0-9_]{1,79}$/),
+  condition: z8.object({
+    eventName: z8.string().regex(/^[a-z][a-z0-9_]{1,79}$/).optional(),
+    eventKind: z8.enum(["browser", "form", "call", "crm", "transaction", "custom_server", "conversion", "delivery"]).optional(),
+    source: z8.string().min(1).max(80).optional(),
+    stageId: z8.string().max(240).optional(),
+    status: z8.enum(["open", "won", "lost", "spam", "unknown"]).optional(),
+    answered: z8.boolean().optional(),
+    minimumCallDurationSeconds: z8.number().int().min(0).max(86400).optional(),
+    excludedTags: z8.array(z8.string().max(80)).max(30).default([]),
+    requiredTags: z8.array(z8.string().max(80)).max(30).default([])
+  }),
+  defaultValueMinor: z8.number().int().min(0).max(Number.MAX_SAFE_INTEGER).optional(),
+  defaultCurrency: z8.string().length(3).default("USD"),
+  enabled: z8.boolean().default(true)
+};
+var AnalyticsEventDefinitionFields = {
+  name: z8.string().min(1).max(120).describe("Human-readable definition name unique within the Site."),
+  eventName: z8.string().regex(/^[a-z][a-z0-9_]{1,79}$/).describe("Canonical event name emitted when this definition matches."),
+  triggerKind: z8.enum(["page", "click", "form", "semantic"]).describe("Declarative browser trigger. Semantic uses a data-xray-event tag."),
+  path: z8.string().startsWith("/").max(2e3).optional().describe("URL path required for page triggers."),
+  pathMatch: z8.enum(["exact", "prefix"]).default("exact").describe("Whether the page path must equal or begin with path."),
+  selector: z8.string().min(1).max(500).optional().describe("CSS selector evaluated only by the first-party Pixel for click or form triggers."),
+  hostnames: z8.array(z8.string().min(1).max(253)).max(25).default([]).describe("Optional approved bare hostnames. Empty applies across the Site Pixel hosts."),
+  metadata: z8.object({
+    value: z8.number().finite().min(0).max(1e12).optional().describe("Optional non-negative conversion value in major currency units."),
+    currency: z8.string().regex(/^[A-Za-z]{3}$/).optional().describe("ISO 4217 currency code for value."),
+    orderId: z8.string().min(1).max(200).optional().describe("Optional stable order identifier."),
+    contentId: z8.string().min(1).max(200).optional().describe("Optional product or content identifier."),
+    contentType: z8.string().min(1).max(80).optional().describe("Optional bounded content category.")
+  }).strict().optional().describe("Safe fixed event metadata; never form field values or arbitrary code."),
+  oncePerSession: z8.boolean().default(false).describe("Emit at most once per browser session when true."),
+  enabled: z8.boolean().default(true).describe("Whether the Pixel may emit this definition.")
+};
+var AnalyticsCreateEventDefinitionInputSchema = {
+  siteId: z8.string().uuid(),
+  ...AnalyticsEventDefinitionFields
+};
+var AnalyticsUpdateEventDefinitionInputSchema = {
+  siteId: z8.string().uuid(),
+  definitionId: z8.string().uuid().describe("Event definition id returned by analytics_list_event_definitions."),
+  name: AnalyticsEventDefinitionFields.name.optional(),
+  eventName: AnalyticsEventDefinitionFields.eventName.optional(),
+  triggerKind: AnalyticsEventDefinitionFields.triggerKind.optional(),
+  path: z8.string().startsWith("/").max(2e3).nullable().optional().describe("Replacement page path; null clears it."),
+  pathMatch: z8.enum(["exact", "prefix"]).optional().describe("Replacement page path match mode."),
+  selector: z8.string().min(1).max(500).nullable().optional().describe("Replacement browser-only selector; null clears it."),
+  hostnames: z8.array(z8.string().min(1).max(253)).max(25).optional().describe("Replacement approved bare-hostname scope."),
+  metadata: AnalyticsEventDefinitionFields.metadata.unwrap().nullable().optional().describe("Replacement safe metadata; null clears it."),
+  oncePerSession: z8.boolean().optional().describe("Replacement once-per-browser-session behavior."),
+  enabled: z8.boolean().optional().describe("Replacement enabled state.")
+};
+var AnalyticsArchiveEventDefinitionInputSchema = {
+  siteId: z8.string().uuid(),
+  definitionId: z8.string().uuid().describe("Event definition id returned by analytics_list_event_definitions.")
+};
+var AnalyticsTestEventDefinitionInputSchema = {
+  siteId: z8.string().uuid(),
+  definitionId: z8.string().uuid().describe("Event definition id returned by analytics_list_event_definitions."),
+  hostname: z8.string().min(1).max(253).describe("Bare hostname observed by the browser."),
+  path: z8.string().startsWith("/").max(2e3).describe("URL path observed by the browser."),
+  triggerKind: z8.enum(["page", "click", "form", "semantic"]).describe("Trigger interaction being previewed."),
+  tagEventName: z8.string().regex(/^[a-z][a-z0-9_]{1,79}$/).optional().describe("Validated data-xray-event name observed by the browser."),
+  selectorMatched: z8.boolean().optional().describe("The browser-reported match result. The server never receives HTML or evaluates a selector.")
+};
+var AnalyticsTestActivationDestinationInputSchema = {
+  siteId: z8.string().uuid(),
+  destinationId: z8.string().uuid().describe("Activation destination id returned by analytics_list_activation_destinations.")
+};
+var AnalyticsListActivationReceiptsInputSchema = {
+  siteId: z8.string().uuid(),
+  destinationId: z8.string().uuid().describe("Activation destination id returned by analytics_list_activation_destinations."),
+  limit: z8.number().int().min(1).max(250).default(50).describe("Maximum receipt rows to return."),
+  cursor: z8.string().max(1e3).optional().describe("Opaque pagination cursor from the prior receipt page.")
+};
+var AnalyticsRetryActivationDeliveryInputSchema = {
+  siteId: z8.string().uuid(),
+  jobId: z8.string().uuid().describe("Failed activation job id returned by analytics_list_activation_receipts.")
+};
+var AnalyticsReconcileConnectionInputSchema = {
+  siteId: z8.string().uuid(),
+  connectionId: z8.string().uuid().describe("Phone or CRM connection id returned by analytics_list_connections.")
+};
+var AnalyticsRecordExternalEventInputSchema = {
+  siteId: z8.string().uuid(),
+  schemaVersion: z8.literal(1).default(1),
+  eventId: z8.string().min(8).max(200),
+  source: z8.string().min(1).max(80),
+  sourceAccountRef: z8.string().min(1).max(240),
+  sourceEventId: z8.string().min(1).max(300),
+  eventKind: z8.enum(["browser", "form", "call", "crm", "transaction", "custom_server", "conversion", "delivery"]),
+  eventName: z8.string().regex(/^[a-z][a-z0-9_]{1,79}$/),
+  occurredAt: z8.string().datetime(),
+  visitorId: z8.string().max(160).optional(),
+  sessionId: z8.string().max(160).optional(),
+  callId: z8.string().max(240).optional(),
+  dealId: z8.string().max(240).optional(),
+  orderId: z8.string().max(240).optional(),
+  personRef: z8.string().max(240).optional(),
+  path: z8.string().max(2e3).optional(),
+  canonicalUrl: z8.string().url().max(3e3).optional(),
+  sourceName: z8.string().max(180).optional(),
+  medium: z8.string().max(180).optional(),
+  campaign: z8.string().max(240).optional(),
+  valueMinor: z8.number().int().min(0).max(2147483647).optional(),
+  currency: z8.string().length(3).optional(),
+  clickIds: z8.object({
+    gclid: z8.string().max(500).optional(),
+    gbraid: z8.string().max(500).optional(),
+    wbraid: z8.string().max(500).optional(),
+    fbclid: z8.string().max(500).optional(),
+    fbp: z8.string().max(500).optional(),
+    fbc: z8.string().max(500).optional(),
+    ttclid: z8.string().max(500).optional(),
+    rdt_cid: z8.string().max(500).optional(),
+    msclkid: z8.string().max(500).optional(),
+    li_fat_id: z8.string().max(500).optional(),
+    snapclid: z8.string().max(500).optional()
+  }).optional(),
+  properties: z8.record(z8.string(), z8.unknown()).optional()
+};
+var AnalyticsJourneyInputSchema = {
+  siteId: z8.string().uuid(),
+  personId: z8.string().uuid()
 };
 var AnalyticsCrmImportInputSchema = {
   siteId: z8.string().uuid(),
@@ -11036,7 +11219,12 @@ function registerAnalyticsMcpTools(server, executor) {
     ["analytics_list_campaign_links", "List Campaign Links", "List paginated tracked links and canonical UTM and ad hierarchy fields.", AnalyticsSiteResourceInputSchema, "analyticsListCampaignLinks"],
     ["analytics_list_forms", "List Analytics Forms", "List paginated Pixel-linked forms, embed snippets, fields, versions, and submission counts.", AnalyticsSiteResourceInputSchema, "analyticsListForms"],
     ["analytics_list_crm_imports", "List CRM Imports", "List paginated encrypted CSV import receipts without exposing contact PII in analytics.", AnalyticsSiteResourceInputSchema, "analyticsListCrmImports"],
-    ["analytics_list_activation_destinations", "List Ad Activation Destinations", "List Meta, Google, TikTok, and Reddit destinations with pending, delivered, and failed conversion counts.", AnalyticsSiteResourceInputSchema, "analyticsListActivationDestinations"]
+    ["analytics_list_activation_destinations", "List Ad Activation Destinations", "List Meta, Google, TikTok, and Reddit destinations with pending, delivered, and failed conversion counts.", AnalyticsSiteResourceInputSchema, "analyticsListActivationDestinations"],
+    ["analytics_list_connections", "List X-Ray Connections", "List phone, CRM, and webhook connections with honest readiness, receipt, and error state.", AnalyticsSiteResourceInputSchema, "analyticsListConnections"],
+    ["analytics_list_conversion_rules", "List Conversion Rules", "List deterministic versioned rules that turn canonical phone, CRM, transaction, and server events into conversions.", AnalyticsSiteResourceInputSchema, "analyticsListConversionRules"],
+    ["analytics_list_event_definitions", "List Browser Event Definitions", "List declarative page, click, and form-submit tags applied by the first-party X-Ray Pixel.", AnalyticsSiteResourceInputSchema, "analyticsListEventDefinitions"],
+    ["analytics_get_coverage", "Get Attribution Coverage", "Measure click-ID coverage and call/CRM journey join rates. Null rates mean there is not yet a denominator.", AnalyticsSiteResourceInputSchema, "analyticsGetCoverage"],
+    ["analytics_get_person_journey", "Get Person Journey", "Read one identified person timeline across sessions, immutable touches, calls, CRM stages, conversions, and ad-delivery receipts.", AnalyticsJourneyInputSchema, "analyticsGetPersonJourney"]
   ];
   for (const [name, title, description, inputSchema, handler] of reads) {
     server.registerTool(name, {
@@ -11048,12 +11236,16 @@ function registerAnalyticsMcpTools(server, executor) {
     }, async (input) => executor[handler](input));
   }
   const writes = [
-    ["analytics_create_campaign_link", "Create Campaign Link", "Create one tracked campaign URL with canonical UTMs and optional ad-group, ad, and creative identifiers.", AnalyticsCreateCampaignLinkInputSchema, "analyticsCreateCampaignLink"],
-    ["analytics_create_form", "Create Pixel-linked Form", "Create and optionally publish a branded form that inherits the parent Pixel identity and session.", AnalyticsCreateFormInputSchema, "analyticsCreateForm"],
-    ["analytics_create_activation_destination", "Create Ad Activation Destination", "Create a Meta, Google, TikTok, or Reddit conversion destination using an existing provider connection reference.", AnalyticsCreateActivationInputSchema, "analyticsCreateActivation"],
-    ["analytics_import_crm_csv", "Import CRM CSV", "Map and stage a bounded CRM CSV import. Contact fields are encrypted and analytics retains only opaque person references and identity signals.", AnalyticsCrmImportInputSchema, "analyticsImportCrmCsv"]
+    ["analytics_create_campaign_link", "Create Campaign Link", "Create one tracked campaign URL with canonical UTMs and optional ad-group, ad, and creative identifiers.", AnalyticsCreateCampaignLinkInputSchema, "analyticsCreateCampaignLink", false],
+    ["analytics_create_form", "Create Pixel-linked Form", "Create and optionally publish a branded form that inherits the parent Pixel identity and session.", AnalyticsCreateFormInputSchema, "analyticsCreateForm", false],
+    ["analytics_create_activation_destination", "Create Ad Activation Destination", "Create a Meta, Google, TikTok, or Reddit conversion destination using an existing provider connection reference.", AnalyticsCreateActivationInputSchema, "analyticsCreateActivation", false],
+    ["analytics_create_connection", "Create X-Ray Connection", "Create a CallRail, CallTrackingMetrics, Twilio, HubSpot, HighLevel, or generic CRM connection. Creation is configured-unverified until a signed receipt succeeds.", AnalyticsCreateConnectionInputSchema, "analyticsCreateConnection", false],
+    ["analytics_create_conversion_rule", "Create Conversion Rule", "Create a versioned declarative conversion rule. This is a safe event-routing layer, not arbitrary JavaScript like Google Tag Manager.", AnalyticsCreateRuleInputSchema, "analyticsCreateConversionRule", false],
+    ["analytics_create_event_definition", "Create Browser Event Definition", "Create a declarative page, click, or third-party form-submit event tag without injecting arbitrary JavaScript or capturing form fields.", AnalyticsCreateEventDefinitionInputSchema, "analyticsCreateEventDefinition", false],
+    ["analytics_record_external_event", "Record Server Event", "Idempotently record a canonical server-side call, CRM, transaction, or custom event and evaluate conversion rules.", AnalyticsRecordExternalEventInputSchema, "analyticsRecordExternalEvent", true],
+    ["analytics_import_crm_csv", "Import CRM CSV", "Map and stage a bounded CRM CSV import. Contact fields are encrypted and analytics retains only opaque person references and identity signals.", AnalyticsCrmImportInputSchema, "analyticsImportCrmCsv", false]
   ];
-  for (const [name, title, description, inputSchema, handler] of writes) {
+  for (const [name, title, description, inputSchema, handler, idempotent] of writes) {
     server.registerTool(name, {
       title,
       description,
@@ -11063,11 +11255,35 @@ function registerAnalyticsMcpTools(server, executor) {
         title,
         readOnlyHint: false,
         destructiveHint: false,
-        idempotentHint: false,
+        idempotentHint: idempotent,
         openWorldHint: false
       }
     }, async (input) => executor[handler](input));
   }
+  const operations = [
+    ["analytics_update_event_definition", "Update Browser Event Definition", "Update a versioned declarative browser event definition. Null path, selector, or metadata clears that optional field.", AnalyticsUpdateEventDefinitionInputSchema, "analyticsUpdateEventDefinition", false, false, false, false],
+    ["analytics_archive_event_definition", "Archive Browser Event Definition", "Idempotently archive a browser event definition so the Pixel no longer receives it.", AnalyticsArchiveEventDefinitionInputSchema, "analyticsArchiveEventDefinition", false, true, true, false],
+    ["analytics_test_event_definition", "Test Browser Event Definition", "Preview a definition against validated hostname, path, trigger, tag, and browser-reported selector-match facts. This never accepts HTML or executes selectors server-side.", AnalyticsTestEventDefinitionInputSchema, "analyticsTestEventDefinition", true, true, false, false],
+    ["analytics_test_activation_destination", "Test Ad Activation Destination", "Send the provider-specific verification test for a configured activation destination and return its safe receipt.", AnalyticsTestActivationDestinationInputSchema, "analyticsTestActivationDestination", false, false, false, true],
+    ["analytics_list_activation_receipts", "List Ad Activation Receipts", "List bounded provider delivery receipts for one activation destination.", AnalyticsListActivationReceiptsInputSchema, "analyticsListActivationReceipts", true, true, false, false],
+    ["analytics_retry_activation_delivery", "Retry Ad Activation Delivery", "Requeue one failed or dead-lettered activation job. This may cause an external provider delivery.", AnalyticsRetryActivationDeliveryInputSchema, "analyticsRetryActivationDelivery", false, false, false, true],
+    ["analytics_reconcile_connection", "Reconcile X-Ray Connection", "Reconcile one phone or CRM connection through its configured provider API and return readiness and checkpoint evidence.", AnalyticsReconcileConnectionInputSchema, "analyticsReconcileConnection", false, true, false, true]
+  ];
+  for (const [name, title, description, inputSchema, handler, readOnly, idempotent, destructive, openWorld] of operations) {
+    server.registerTool(name, {
+      title,
+      description,
+      inputSchema,
+      outputSchema: recordOutputSchema(name, AnalyticsGenericOutputSchema),
+      annotations: {
+        title,
+        readOnlyHint: readOnly,
+        destructiveHint: destructive,
+        idempotentHint: idempotent,
+        openWorldHint: openWorld
+      }
+    }, async (input) => executor[handler](input));
+  }
   server.registerTool("analytics_get_health", {
     title: "Analytics Pixel Health",
     description: "Read ingestion health for one analytics Business, including Pixel activity, last event and conversion timestamps, rollup state, and rejection signals.",
@@ -12136,6 +12352,18 @@ async function readResponseData(res) {
     return text;
   }
 }
+function attachJsonStructuredContent(result) {
+  if (result.isError || result.structuredContent) return result;
+  const text = result.content.find((part) => part.type === "text");
+  if (!text || text.type !== "text") return result;
+  try {
+    const parsed = JSON.parse(text.text);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return result;
+    return { ...result, structuredContent: parsed };
+  } catch {
+    return result;
+  }
+}
 function httpErrorPayload(path, res, data) {
   const objectData = data && typeof data === "object" && !Array.isArray(data) ? data : null;
   const rawCode = objectData?.code ?? objectData?.errorCode ?? objectData?.error_code;
@@ -12673,6 +12901,21 @@ var HttpMcpToolExecutor = class {
   analyticsListActivationDestinations(input) {
     return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/activation-destinations`);
   }
+  analyticsListConnections(input) {
+    return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/connections`);
+  }
+  analyticsListConversionRules(input) {
+    return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/conversion-rules`);
+  }
+  analyticsListEventDefinitions(input) {
+    return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/event-definitions`);
+  }
+  analyticsGetCoverage(input) {
+    return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/coverage`);
+  }
+  analyticsGetPersonJourney(input) {
+    return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/people/${encodeURIComponent(input.personId)}/journey`);
+  }
   analyticsCreateCampaignLink(input) {
     const { siteId, ...body } = input;
     return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/campaign-links`, body, this.timeoutMs, "POST");
@@ -12685,6 +12928,47 @@ var HttpMcpToolExecutor = class {
     const { siteId, ...body } = input;
     return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/activation-destinations`, body, this.timeoutMs, "POST");
   }
+  analyticsCreateConnection(input) {
+    const { siteId, ...body } = input;
+    return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/connections`, body, this.timeoutMs, "POST");
+  }
+  analyticsCreateConversionRule(input) {
+    const { siteId, ...body } = input;
+    return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/conversion-rules`, body, this.timeoutMs, "POST");
+  }
+  analyticsCreateEventDefinition(input) {
+    const { siteId, ...body } = input;
+    return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/event-definitions`, body, this.timeoutMs, "POST");
+  }
+  analyticsUpdateEventDefinition(input) {
+    const { siteId, definitionId, ...body } = input;
+    return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/event-definitions/${encodeURIComponent(definitionId)}`, body, this.timeoutMs, "PATCH");
+  }
+  analyticsArchiveEventDefinition(input) {
+    return this.call(`/analytics/sites/${encodeURIComponent(input.siteId)}/event-definitions/${encodeURIComponent(input.definitionId)}`, {}, this.timeoutMs, "DELETE");
+  }
+  analyticsTestEventDefinition(input) {
+    const { siteId, definitionId, ...body } = input;
+    return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/event-definitions/${encodeURIComponent(definitionId)}/test`, body, this.timeoutMs, "POST");
+  }
+  analyticsTestActivationDestination(input) {
+    return this.call(`/analytics/sites/${encodeURIComponent(input.siteId)}/activation-destinations/${encodeURIComponent(input.destinationId)}/test`, {}, this.timeoutMs, "POST");
+  }
+  analyticsListActivationReceipts(input) {
+    const query = new URLSearchParams({ limit: String(input.limit) });
+    if (input.cursor) query.set("cursor", input.cursor);
+    return this.getJson(`/analytics/sites/${encodeURIComponent(input.siteId)}/activation-destinations/${encodeURIComponent(input.destinationId)}/receipts?${query}`);
+  }
+  analyticsRetryActivationDelivery(input) {
+    return this.call(`/analytics/sites/${encodeURIComponent(input.siteId)}/activation-jobs/${encodeURIComponent(input.jobId)}/retry`, {}, this.timeoutMs, "POST");
+  }
+  analyticsReconcileConnection(input) {
+    return this.call(`/analytics/sites/${encodeURIComponent(input.siteId)}/connections/${encodeURIComponent(input.connectionId)}/reconcile`, {}, this.timeoutMs, "POST");
+  }
+  analyticsRecordExternalEvent(input) {
+    const { siteId, ...body } = input;
+    return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/external-events`, body, this.timeoutMs, "POST");
+  }
   analyticsImportCrmCsv(input) {
     const { siteId, ...body } = input;
     return this.call(`/analytics/sites/${encodeURIComponent(siteId)}/crm-imports`, body, this.timeoutMs, "POST");
@@ -12746,8 +13030,8 @@ var HttpMcpToolExecutor = class {
   commonsGetProposal(input) {
     return this.getJson(`/commons/proposals/${encodeURIComponent(input.proposalId)}`);
   }
-  commonsHostImage(input) {
-    return this.call("/commons/images", input);
+  async commonsHostImage(input) {
+    return attachJsonStructuredContent(await this.call("/commons/images", input));
   }
   commonsUpdateEditorialArticle(input) {
     const { idempotencyKey, ...body } = input;

package/dist/{chunk-AYJHI2FK.js → chunk-WNL42AMC.js}

@@ -213,8 +213,8 @@ var PUBLIC_PRODUCT_CONTRACT = {
     "freeSignupCredits": 0
   },
   "inventory": {
-    "totalTools": 259,
-    "scraperTools": 158,
+    "totalTools": 275,
+    "scraperTools": 174,
     "memoryTools": 101
   },
   "concurrencyPack": {

package/dist/{chunk-IHDTONZV.js → chunk-XKWTKQ7Y.js}

@@ -1,6 +1,6 @@
 // release-message.json
 var release_message_default = {
-  message: "Transparent Commons can now turn pasted images, generated image bytes, stored image artifacts, direct image URLs, or ordinary webpage URLs into one permanent Commons-hosted image before validation and publishing."
+  message: "X-Ray now unifies browser, phone, CRM, and checkout conversions and delivers eligible events through verified advertising destinations with durable receipts."
 };
 
 // src/install-terminal.ts
@@ -55,7 +55,7 @@ function renderInstallTerminal(options) {
     "1/1 install surfaces ready",
     colorize(`Newest in v${options.version}: ${release_message_default.message}`, "lime", color),
     "",
-    `${colorize("Tools", "cyan", color)}  ${colorize("(259 MCP tools)", "muted", color)}`,
+    `${colorize("Tools", "cyan", color)}  ${colorize("(275 MCP tools)", "muted", color)}`,
     toolRow("search", ["harvest_paa", "search_serp", "maps_search", "maps_place_intel"], color),
     toolRow("extract", ["extract_url", "map_site_urls", "extract_site", "audit_site", "directory_workflow"], color),
     toolRow("build", ["create_editorial_reading_room", "rank_tracker_workflow", "portable HTML"], color),

package/dist/{chunk-LCGTNWOT.js → chunk-YUGC5K35.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-DNM65UCK.js";
 import {
   LedgerOperation
-} from "./chunk-AYJHI2FK.js";
+} from "./chunk-WNL42AMC.js";
 import {
   CREDIT_LOT_TTL,
   getDb,

package/dist/{extract-bundle-QQIYJSBW.js → extract-bundle-TBETDXWP.js}

@@ -18,9 +18,9 @@ import {
   createSiteExtractContentReader,
   createSiteExtractImageArtifact,
   extractJobLimitInfo
-} from "./chunk-LCGTNWOT.js";
+} from "./chunk-YUGC5K35.js";
 import "./chunk-DNM65UCK.js";
-import "./chunk-AYJHI2FK.js";
+import "./chunk-WNL42AMC.js";
 import {
   getDb
 } from "./chunk-65FTMB7G.js";