chore: import upstream snapshot with attribution

apps/sim/lib/copilot/integration-tools.ts

@@ -0,0 +1,103 @@
+import type { BlockVisibilityState } from '@/lib/core/config/block-visibility'
+import { BLOCK_REGISTRY } from '@/blocks/registry-maps'
+import { isHiddenUnder } from '@/blocks/visibility/context'
+import { tools as toolRegistry } from '@/tools/registry'
+import type { ToolConfig } from '@/tools/types'
+import { getLatestVersionTools, stripVersionSuffix } from '@/tools/utils'
+
+export interface ExposedIntegrationTool {
+  /**
+   * Full registry tool id — also the agent-callable id and the schema `id`
+   * field (e.g. gmail_read_v2). No stripping: discovery, the schema id, and the
+   * callable id are all this exact value, matching the block's tools.access.
+   */
+  toolId: string
+  config: ToolConfig
+  /** Service directory name, e.g. "gmail". */
+  service: string
+  /** Operation stem within the service (used for the VFS path filename), e.g. "read". */
+  operation: string
+  /** Owning block's registry type — the key block-visibility rules gate on. */
+  blockType: string
+  /** Owning block's static `preview` marker, for the per-viewer filter. */
+  preview?: boolean
+}
+
+let cached: ExposedIntegrationTool[] | null = null
+
+/**
+ * Returns the UNGATED universe of integration tools exposable to the copilot
+ * agent: the latest version of each operation owned by a non-`hideFromToolbar`
+ * block — INCLUDING unreleased `preview` blocks.
+ *
+ * Deliberately sourced from the raw `BLOCK_REGISTRY` (never the visibility-
+ * projected `getAllBlocks`) so this process-global memo is deterministic and
+ * can never be poisoned by whichever viewer's gated projection ran first.
+ * Every per-viewer consumer MUST apply {@link filterExposedIntegrationTools}
+ * before exposing the set.
+ *
+ * This is the single source of truth shared by VFS discovery
+ * (components/integrations/**) and the deferred callable-tool payload, so the
+ * agent can call exactly what it can discover — no orphan callable tools, and no
+ * version drift between what the VFS shows and what is loadable.
+ */
+export function getExposedIntegrationTools(): ExposedIntegrationTool[] {
+  if (cached) return cached
+
+  // Map the tool ids each visible block exposes (both the raw id and its
+  // version-stripped base name) to that block's service directory + type.
+  const toolToBlock = new Map<string, { service: string; blockType: string; preview?: boolean }>()
+  for (const block of Object.values(BLOCK_REGISTRY)) {
+    if (block.hideFromToolbar) continue
+    if (!block.tools?.access) continue
+    const service = stripVersionSuffix(block.type)
+    const owner = { service, blockType: block.type, preview: block.preview }
+    for (const toolId of block.tools.access) {
+      toolToBlock.set(toolId, owner)
+      toolToBlock.set(stripVersionSuffix(toolId), owner)
+    }
+  }
+
+  const exposed: ExposedIntegrationTool[] = []
+  const seen = new Set<string>()
+  for (const [toolId, config] of Object.entries(getLatestVersionTools(toolRegistry))) {
+    const baseName = stripVersionSuffix(toolId)
+    const owner = toolToBlock.get(toolId) ?? toolToBlock.get(baseName)
+    if (!owner) continue
+    if (seen.has(baseName)) continue
+    seen.add(baseName)
+    const prefix = `${owner.service}_`
+    const operation = baseName.startsWith(prefix) ? baseName.slice(prefix.length) : baseName
+    exposed.push({
+      toolId,
+      config,
+      service: owner.service,
+      operation,
+      blockType: owner.blockType,
+      preview: owner.preview,
+    })
+  }
+
+  cached = exposed
+  return exposed
+}
+
+/**
+ * Per-viewer projection of the exposed set: drops tools whose owning block is
+ * hidden under `vis` (unrevealed preview blocks — including with a null state —
+ * and kill-switched types). Apply at every surface that hands the set to a
+ * viewer: VFS stamping, the deferred tool payload, `list_integration_tools`.
+ */
+export function filterExposedIntegrationTools(
+  tools: ExposedIntegrationTool[],
+  vis: BlockVisibilityState | null
+): ExposedIntegrationTool[] {
+  return tools.filter(
+    (tool) => !isHiddenUnder(vis, { type: tool.blockType, preview: tool.preview })
+  )
+}
+
+/** Test-only: clears the memoized set so registry changes are picked up. */
+export function resetExposedIntegrationToolsCache(): void {
+  cached = null
+}