@canonry/canonry 4.154.1 → 4.156.0

package/dist/{chunk-ANSQ6JNO.js → chunk-CPASKGUE.js}

@@ -81,7 +81,7 @@ import {
   trafficConnectWordpressRequestSchema,
   trafficEventKindSchema,
   trafficSeriesGranularitySchema
-} from "./chunk-NNW7TJUZ.js";
+} from "./chunk-AMPT2EP7.js";
 
 // src/config.ts
 import fs from "fs";
@@ -4907,6 +4907,126 @@ var getApiV1ProjectsByNameTechnicalAeoTrend = (options) => {
     ...options
   });
 };
+var getApiV1ProjectsByNameTechnicalAeoCrawl = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/crawl",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoSubgraph = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/subgraph",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoPath = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/path",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoChanges = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/changes",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoCrawlPagesAudit = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/crawl/pages/audit",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoCrawlPages = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/crawl/pages",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoStructure = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/structure",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoInternalLinks = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/internal-links",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoInternalLinksNeighbors = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/internal-links/neighbors",
+    ...options
+  });
+};
+var getApiV1ProjectsByNameTechnicalAeoDeadLinks = (options) => {
+  return (options.client ?? client).get({
+    security: [
+      {
+        scheme: "bearer",
+        type: "http"
+      }
+    ],
+    url: "/api/v1/projects/{name}/technical-aeo/dead-links",
+    ...options
+  });
+};
 var postApiV1ProjectsByNameTechnicalAeoRuns = (options) => {
   return (options.client ?? client).post({
     security: [
@@ -7041,6 +7161,161 @@ var ApiClient = class {
       })
     );
   }
+  /** Persisted full-crawl metadata. This never synthesizes a graph from legacy audit rows. */
+  async getTechnicalAeoCrawl(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoCrawl({
+        client: this.heyClient,
+        path: { name: project },
+        query: { runId: opts?.runId }
+      })
+    );
+  }
+  /** Bounded semantic Site Health neighborhood; this never returns visualization layout. */
+  async getSiteHealthSubgraph(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoSubgraph({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts?.runId,
+          nodeKey: opts?.nodeKey,
+          url: opts?.url,
+          hops: opts?.hops,
+          maxNodes: opts?.maxNodes,
+          maxEdges: opts?.maxEdges
+        }
+      })
+    );
+  }
+  /** Directed shortest path over persisted, followable internal links. */
+  async getSiteHealthPath(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoPath({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts.runId,
+          fromNodeKey: opts.fromNodeKey,
+          fromUrl: opts.fromUrl,
+          toNodeKey: opts.toNodeKey,
+          toUrl: opts.toUrl,
+          maxDepth: opts.maxDepth
+        }
+      })
+    );
+  }
+  /** Cursor-paged canonical page/link changes between immutable complete crawls. */
+  async getSiteHealthChanges(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoChanges({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          fromRunId: opts?.fromRunId,
+          toRunId: opts?.toRunId,
+          scope: opts?.scope,
+          change: opts?.change,
+          cursor: opts?.cursor,
+          limit: opts?.limit
+        }
+      })
+    );
+  }
+  /** Bounded, cursor-paged crawl nodes. */
+  async getTechnicalAeoCrawlPages(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoCrawlPages({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts?.runId,
+          inventoryEligible: opts?.inventoryEligible,
+          fetchState: opts?.fetchState,
+          indexabilityState: opts?.indexabilityState,
+          auditState: opts?.auditState,
+          sort: opts?.sort,
+          cursor: opts?.cursor,
+          limit: opts?.limit !== void 0 ? String(opts.limit) : void 0
+        }
+      })
+    );
+  }
+  /** Exact page-scoped audit evidence tied to a persisted crawl node. */
+  async getTechnicalAeoPageAudit(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoCrawlPagesAudit({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts.runId,
+          nodeKey: opts.nodeKey,
+          url: opts.url
+        }
+      })
+    );
+  }
+  /** One bounded path level from a persisted crawl. */
+  async getTechnicalAeoStructure(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoStructure({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts?.runId,
+          parentPath: opts?.parentPath,
+          cursor: opts?.cursor,
+          limit: opts?.limit !== void 0 ? String(opts.limit) : void 0
+        }
+      })
+    );
+  }
+  /** Bounded, cursor-paged internal crawl edges. */
+  async getTechnicalAeoInternalLinks(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoInternalLinks({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts?.runId,
+          sourceUrl: opts?.sourceUrl,
+          targetUrl: opts?.targetUrl,
+          followable: opts?.followable,
+          cursor: opts?.cursor,
+          limit: opts?.limit !== void 0 ? String(opts.limit) : void 0
+        }
+      })
+    );
+  }
+  /** Bounded inbound/outbound internal edges for one crawl node. */
+  async getTechnicalAeoInternalLinkNeighbors(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoInternalLinksNeighbors({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts.runId,
+          nodeKey: opts.nodeKey,
+          url: opts.url,
+          limit: opts.limit !== void 0 ? String(opts.limit) : void 0
+        }
+      })
+    );
+  }
+  /** Dead-link state/findings; `disabled` means the crawl did not opt in. */
+  async getTechnicalAeoDeadLinks(project, opts) {
+    return this.invoke(
+      () => getApiV1ProjectsByNameTechnicalAeoDeadLinks({
+        client: this.heyClient,
+        path: { name: project },
+        query: {
+          runId: opts?.runId,
+          cursor: opts?.cursor,
+          limit: opts?.limit !== void 0 ? String(opts.limit) : void 0
+        }
+      })
+    );
+  }
   async triggerSiteAudit(project, body) {
     return this.invoke(
       () => postApiV1ProjectsByNameTechnicalAeoRuns({
@@ -8209,10 +8484,114 @@ var technicalAeoTrendInputSchema = z3.object({
   project: projectNameSchema,
   limit: z3.number().int().positive().max(365).optional()
 });
+var technicalAeoCrawlInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional().describe("Historical crawl-bearing site-audit run ID. Omit for the latest persisted crawl.")
+});
+var siteHealthPageAuditInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional().describe("Historical crawl-bearing site-audit run ID. Omit for the latest persisted crawl."),
+  nodeKey: z3.string().min(1).optional().describe("Exact crawl node key, as returned by Site Health page or subgraph reads."),
+  url: z3.string().url().optional().describe("Exact page URL. Use this only when a crawl node key is unavailable.")
+}).refine((value) => Boolean(value.nodeKey || value.url), {
+  message: "Provide nodeKey or url.",
+  path: ["nodeKey"]
+}).refine((value) => !(value.nodeKey && value.url), {
+  message: "Provide nodeKey or url, not both.",
+  path: ["nodeKey"]
+});
+var SITE_HEALTH_MCP_MAX_NODES = 25;
+var SITE_HEALTH_MCP_MAX_EDGES = 50;
+var siteHealthSubgraphInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional().describe("Historical crawl-bearing site-audit run ID. Omit for the latest complete crawl."),
+  nodeKey: z3.string().min(1).optional().describe("Focus crawl node key. Omit with url to focus the crawl root."),
+  url: z3.string().url().optional().describe("Focus canonical URL. Omit with nodeKey to focus the crawl root."),
+  hops: z3.number().int().min(0).max(3).optional().describe("Neighborhood depth from the focus node. Keep this small."),
+  maxNodes: z3.number().int().positive().max(SITE_HEALTH_MCP_MAX_NODES).default(SITE_HEALTH_MCP_MAX_NODES).describe("Hard MCP cap: at most 25 nodes. Narrow or refocus instead of loading the site."),
+  maxEdges: z3.number().int().positive().max(SITE_HEALTH_MCP_MAX_EDGES).default(SITE_HEALTH_MCP_MAX_EDGES).describe("Hard MCP cap: at most 50 edges. Narrow or refocus instead of loading the site.")
+}).refine((value) => !(value.nodeKey && value.url), {
+  message: "Provide nodeKey or url, not both.",
+  path: ["nodeKey"]
+});
+var siteHealthPathInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional().describe("Historical crawl-bearing site-audit run ID. Omit for the latest complete crawl."),
+  fromNodeKey: z3.string().min(1).optional().describe("Origin node key. Omit with fromUrl to start at the crawl root."),
+  fromUrl: z3.string().url().optional().describe("Origin URL. Omit with fromNodeKey to start at the crawl root."),
+  toNodeKey: z3.string().min(1).optional().describe("Required destination node key."),
+  toUrl: z3.string().url().optional().describe("Required destination URL."),
+  maxDepth: z3.number().int().positive().max(24).optional().describe("Maximum directed-link depth to search.")
+}).refine((value) => !(value.fromNodeKey && value.fromUrl), {
+  message: "Provide fromNodeKey or fromUrl, not both.",
+  path: ["fromNodeKey"]
+}).refine((value) => Boolean(value.toNodeKey || value.toUrl), {
+  message: "Provide toNodeKey or toUrl.",
+  path: ["toNodeKey"]
+}).refine((value) => !(value.toNodeKey && value.toUrl), {
+  message: "Provide toNodeKey or toUrl, not both.",
+  path: ["toNodeKey"]
+});
+var siteHealthChangesInputSchema = z3.object({
+  project: projectNameSchema,
+  fromRunId: runIdSchema.optional().describe("Earlier complete crawl run ID. Omit to compare the previous complete crawl."),
+  toRunId: runIdSchema.optional().describe("Later complete crawl run ID. Omit to compare the latest complete crawl."),
+  scope: z3.enum(["all", "pages", "links"]).optional().describe("Limit the diff to page or link changes. Omit or use all for both."),
+  change: z3.enum(["all", "added", "removed", "changed"]).optional().describe("Limit the diff to one change kind. Omit or use all for every kind."),
+  cursor: z3.string().min(1).optional().describe("Opaque cursor from the previous Site Health changes result."),
+  limit: z3.number().int().positive().max(25).default(25).describe("Hard MCP cap: 25 records, because each change carries before and after DTOs.")
+});
+var technicalAeoCrawlPagesInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional(),
+  inventoryEligible: z3.boolean().optional().describe("Filter Canonry technical-inventory eligibility. This is not actual Google index coverage."),
+  fetchState: z3.string().min(1).optional().describe("Filter crawler fetch state, for example html, redirect, non-html, or fetch-error."),
+  indexabilityState: z3.string().min(1).optional().describe("Filter crawler-derived indexability state. This is not Google index coverage."),
+  auditState: z3.string().min(1).optional().describe("Filter audit state."),
+  sort: z3.enum(["url", "path", "score-asc", "score-desc"]).optional(),
+  cursor: z3.string().min(1).optional().describe("Opaque cursor from the previous crawl-pages result."),
+  limit: z3.number().int().positive().max(200).optional()
+});
+var technicalAeoStructureInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional(),
+  parentPath: z3.string().min(1).optional().describe("Path whose immediate children to list. Defaults to /. This never returns a whole site tree."),
+  cursor: z3.string().min(1).optional().describe("Opaque cursor from the previous structure result."),
+  limit: z3.number().int().positive().max(100).optional()
+});
+var technicalAeoInternalLinksInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional(),
+  sourceUrl: z3.string().url().optional(),
+  targetUrl: z3.string().url().optional(),
+  followable: z3.boolean().optional(),
+  cursor: z3.string().min(1).optional().describe("Opaque cursor from the previous internal-links result."),
+  limit: z3.number().int().positive().max(200).optional()
+});
+var technicalAeoLinkNeighborsInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional(),
+  nodeKey: z3.string().min(1).optional(),
+  url: z3.string().url().optional(),
+  limit: z3.number().int().positive().max(100).optional()
+}).refine((value) => Boolean(value.nodeKey || value.url), {
+  message: "Provide nodeKey or url.",
+  path: ["nodeKey"]
+});
+var technicalAeoDeadLinksInputSchema = z3.object({
+  project: projectNameSchema,
+  runId: runIdSchema.optional(),
+  cursor: z3.string().min(1).optional().describe("Opaque cursor from the previous dead-links result."),
+  limit: z3.number().int().positive().max(200).optional()
+});
 var technicalAeoRunInputSchema = z3.object({
   project: projectNameSchema,
   sitemapUrl: z3.string().url().optional().describe("Override the sitemap URL. Defaults to https://<canonicalDomain>/sitemap.xml."),
-  limit: z3.number().int().positive().max(2e3).optional().describe("Cap pages audited (highest sitemap <priority> first).")
+  limit: z3.number().int().positive().max(2e3).optional().describe("Deprecated compatibility alias for maxPages."),
+  maxPages: z3.number().int().positive().max(5e4).optional().describe("Maximum pages crawled and audited. Defaults to 1,000; hard maximum 50,000."),
+  maxEdges: z3.number().int().positive().max(1e6).optional().describe("Maximum link observations retained for this crawl. Defaults to 100,000; hard maximum 1,000,000."),
+  maxDepth: z3.number().int().min(0).max(100).optional().describe("Maximum internal-link depth from the root page."),
+  checkDeadLinks: z3.boolean().optional().describe("Opt in to internal dead-link checks. Omitted and false both disable checks.")
 });
 var AGENT_WEBHOOK_EVENTS = [
   notificationEventSchema.enum["run.completed"],
@@ -10021,6 +10400,86 @@ var canonryMcpTools = [
     openApiOperations: ["POST /api/v1/projects/{name}/discover/sessions/{id}/promote"],
     handler: (client2, input) => client2.promoteDiscovery(input.project, input.sessionId, input.request)
   }),
+  defineTool({
+    name: "canonry_site_health_overview",
+    title: "Get Site Health overview",
+    description: "Start a Site Health investigation with the latest or selected scan summary: root URL, completeness, crawl and link counts, budgets, versions, termination, and dead-link check state. Follow with a focused Site Health subgraph, shortest path, or scan changes; never request the interactive graph projection through MCP.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoCrawlInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/crawl"],
+    handler: (client2, input) => client2.getTechnicalAeoCrawl(input.project, { runId: input.runId })
+  }),
+  defineTool({
+    name: "canonry_site_health_page_audit",
+    title: "Get Site Health page audit",
+    description: "Connect one graph page's audit score to its exact persisted evidence: factor scores, stable finding codes and messages, recommendations, and critical defects. The response includes crawl provenance and explicit no-crawl, details-unavailable, not-found, not-audited, ready/scores-only states. Use nodeKey from a Site Health page or subgraph read when possible. Link score remains an importance signal, not an audit finding.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: siteHealthPageAuditInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/crawl/pages/audit"],
+    handler: (client2, input) => client2.getTechnicalAeoPageAudit(input.project, {
+      runId: input.runId,
+      nodeKey: input.nodeKey,
+      url: input.url
+    })
+  }),
+  defineTool({
+    name: "canonry_site_health_subgraph",
+    title: "Inspect focused Site Health subgraph",
+    description: "Read a compact canonical neighborhood around one page or the crawl root. Defaults to 25 nodes and 50 edges; expand hops or refocus only when needed. `countAccuracy=lower-bound` means traversal reached a cap, and `complete`/`termination` qualify partial-crawl results. This intentionally omits visualization coordinates and never materializes the full site graph.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: siteHealthSubgraphInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/subgraph"],
+    handler: (client2, input) => client2.getSiteHealthSubgraph(input.project, {
+      runId: input.runId,
+      nodeKey: input.nodeKey,
+      url: input.url,
+      hops: input.hops,
+      maxNodes: input.maxNodes,
+      maxEdges: input.maxEdges
+    })
+  }),
+  defineTool({
+    name: "canonry_site_health_path",
+    title: "Find shortest Site Health path",
+    description: "Find the shortest directed path of followable internal links from the crawl root or a selected page to one required destination. Use `complete` and `termination` to qualify unreachable or truncated outcomes from a partial crawl; it returns one path, not a graph traversal.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: siteHealthPathInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/path"],
+    handler: (client2, input) => client2.getSiteHealthPath(input.project, {
+      runId: input.runId,
+      fromNodeKey: input.fromNodeKey,
+      fromUrl: input.fromUrl,
+      toNodeKey: input.toNodeKey,
+      toUrl: input.toUrl,
+      maxDepth: input.maxDepth
+    })
+  }),
+  defineTool({
+    name: "canonry_site_health_changes",
+    title: "Compare Site Health scans",
+    description: "Compare two immutable complete scans (or the latest pair) for added, removed, and changed canonical pages or links. Results echo resolved filters and scan IDs; the first page has an exact summary, while continuations omit summary/total. MCP pages cap at 25 because every change carries before/after DTOs; filter before paging.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: siteHealthChangesInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/changes"],
+    handler: (client2, input) => client2.getSiteHealthChanges(input.project, {
+      fromRunId: input.fromRunId,
+      toRunId: input.toRunId,
+      scope: input.scope,
+      change: input.change,
+      cursor: input.cursor,
+      limit: input.limit
+    })
+  }),
   defineTool({
     name: "canonry_technical_aeo_score",
     title: "Get Technical AEO score",
@@ -10060,10 +10519,106 @@ var canonryMcpTools = [
     openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/trend"],
     handler: (client2, input) => client2.getTechnicalAeoTrend(input.project, input.limit !== void 0 ? { limit: input.limit } : void 0)
   }),
+  defineTool({
+    name: "canonry_technical_aeo_crawl",
+    title: "Get persisted Technical AEO crawl",
+    description: "Read persisted full-crawl metadata for the latest or selected Technical AEO site-audit run: root URL, crawl/indexability/link-score versions, effective budgets, completeness, counts, and explicit dead-link check state. This does not fabricate a graph from older scorecard-only audits.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoCrawlInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/crawl"],
+    handler: (client2, input) => client2.getTechnicalAeoCrawl(input.project, { runId: input.runId })
+  }),
+  defineTool({
+    name: "canonry_technical_aeo_crawl_pages",
+    title: "List Technical AEO crawl pages",
+    description: "Read one bounded, cursor-paged list of canonical crawl nodes. Filter crawler-derived indexability and audit state, then follow nextCursor; this is technical inventory eligibility, not a claim about Google index coverage.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoCrawlPagesInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/crawl/pages"],
+    handler: (client2, input) => client2.getTechnicalAeoCrawlPages(input.project, {
+      runId: input.runId,
+      inventoryEligible: input.inventoryEligible,
+      fetchState: input.fetchState,
+      indexabilityState: input.indexabilityState,
+      auditState: input.auditState,
+      sort: input.sort,
+      cursor: input.cursor,
+      limit: input.limit
+    })
+  }),
+  defineTool({
+    name: "canonry_technical_aeo_structure",
+    title: "List Technical AEO site structure",
+    description: "Read one bounded level of the persisted site hierarchy below parentPath. Follow nextCursor for more siblings; request a child path separately rather than attempting to materialize the entire website tree.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoStructureInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/structure"],
+    handler: (client2, input) => client2.getTechnicalAeoStructure(input.project, {
+      runId: input.runId,
+      parentPath: input.parentPath,
+      cursor: input.cursor,
+      limit: input.limit
+    })
+  }),
+  defineTool({
+    name: "canonry_technical_aeo_internal_links",
+    title: "List Technical AEO internal links",
+    description: "Read a bounded, cursor-paged list of persisted internal crawl edges. Filter by source URL, target URL, or followability. Use the neighbors tool for one page rather than loading a graph.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoInternalLinksInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/internal-links"],
+    handler: (client2, input) => client2.getTechnicalAeoInternalLinks(input.project, {
+      runId: input.runId,
+      sourceUrl: input.sourceUrl,
+      targetUrl: input.targetUrl,
+      followable: input.followable,
+      cursor: input.cursor,
+      limit: input.limit
+    })
+  }),
+  defineTool({
+    name: "canonry_technical_aeo_link_neighbors",
+    title: "Get Technical AEO page link neighbors",
+    description: "Read bounded inbound and outbound internal links for exactly one crawl node, selected by nodeKey or URL. It returns independent truncation flags for inbound and outbound edges, not a transitive traversal.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoLinkNeighborsInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/internal-links/neighbors"],
+    handler: (client2, input) => client2.getTechnicalAeoInternalLinkNeighbors(input.project, {
+      runId: input.runId,
+      nodeKey: input.nodeKey,
+      url: input.url,
+      limit: input.limit
+    })
+  }),
+  defineTool({
+    name: "canonry_technical_aeo_dead_links",
+    title: "List Technical AEO dead links",
+    description: "Read the persisted dead-link check state and a bounded, cursor-paged list of findings. A disabled result means the crawl was run without opt-in checks; it never means zero dead links.",
+    access: "read",
+    tier: "monitoring",
+    inputSchema: technicalAeoDeadLinksInputSchema,
+    annotations: readAnnotations(),
+    openApiOperations: ["GET /api/v1/projects/{name}/technical-aeo/dead-links"],
+    handler: (client2, input) => client2.getTechnicalAeoDeadLinks(input.project, {
+      runId: input.runId,
+      cursor: input.cursor,
+      limit: input.limit
+    })
+  }),
   defineTool({
     name: "canonry_technical_aeo_run",
     title: "Run Technical AEO site audit",
-    description: "Trigger a site-audit run: crawl the project sitemap and audit every reachable page across the aeo-audit ranking factors. Returns {runId, status}; the audit runs in the background (a large site can take minutes). Idempotent \u2014 if a site-audit is already in flight it returns that run. Poll canonry_run_get with the returned runId, then read canonry_technical_aeo_score.",
+    description: "Start a site-audit run. The run discovers root, sitemap, and linked pages. Its unattended default is 1,000 pages and 100,000 link observations; callers may explicitly raise either to its hard maximum. It returns {runId, status} and continues in the background. If an active run has identical effective options, this tool returns it; different options are refused. Poll canonry_run_get, then read the crawl and score tools.",
     access: "write",
     tier: "monitoring",
     inputSchema: technicalAeoRunInputSchema,
@@ -10071,7 +10626,11 @@ var canonryMcpTools = [
     openApiOperations: ["POST /api/v1/projects/{name}/technical-aeo/runs"],
     handler: (client2, input) => client2.triggerSiteAudit(input.project, {
       sitemapUrl: input.sitemapUrl,
-      limit: input.limit
+      limit: input.limit,
+      maxPages: input.maxPages,
+      maxEdges: input.maxEdges,
+      maxDepth: input.maxDepth,
+      checkDeadLinks: input.checkDeadLinks
     })
   }),
   // ----- OpenAI ads (ChatGPT ads) -----