fix(rich-editor): mention icon fallback + typed sim-link input rule

- mentionIcon never returns undefined: an empty/unrecognized kind (schema default '', or a future
  kind on a sim: link) falls back to a generic icon instead of crashing the chip's render. Adds tests.
- Add a mention input rule so typing `[label](sim:kind/id)` becomes a chip on the closing paren —
  matching the paste/load path (the tokenizer), which previously left typed syntax as literal text.
  A plain InputRule (full-range replace) is used; nodeInputRule would keep the surrounding brackets.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/mention/mention-icon.test.ts

@@ -0,0 +1,17 @@
+/** @vitest-environment node */
+import { Box, File } from 'lucide-react'
+import { describe, expect, it } from 'vitest'
+import { mentionIcon } from './mention-icon'
+import type { MentionKind } from './types'
+
+describe('mentionIcon', () => {
+  it('returns the category icon for a known kind', () => {
+    expect(mentionIcon('file', 'x')).toBe(File)
+  })
+
+  it('falls back to a generic icon for an empty or unrecognized kind (never undefined)', () => {
+    // The schema default is '' and a sim: link could carry a future kind — neither may crash render.
+    expect(mentionIcon('' as unknown as MentionKind, 'x')).toBe(Box)
+    expect(mentionIcon('dataset' as unknown as MentionKind, 'x')).toBe(Box)
+  })
+})

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/mention/mention-icon.ts

@@ -17,11 +17,13 @@ const KIND_ICONS: Record<Exclude<MentionKind, 'integration'>, MentionIcon> = {
 
 /**
  * Resolves the icon for a mention. Integrations use their brand icon from the block registry (keyed by
- * blockType, which is the mention `id`), falling back to a generic icon if the block was since removed
- * so the chip is never icon-less; every other kind uses a lucide category icon. Shared by the menu
+ * blockType, which is the mention `id`), falling back to a generic icon if the block was since removed;
+ * every other kind uses a lucide category icon, falling back to the same generic icon for an empty or
+ * unrecognized kind (the schema default is `''`, and a `sim:` link could carry a kind a future version
+ * adds) — so the result is always a real component and the chip is never icon-less. Shared by the menu
  * rows and the inserted chip so both render the same icon.
  */
 export function mentionIcon(kind: MentionKind, id: string): MentionIcon {
   if (kind === 'integration') return (getBlock(id)?.icon as MentionIcon | undefined) ?? Box
-  return KIND_ICONS[kind]
+  return KIND_ICONS[kind] ?? Box
 }

apps/sim/app/workspace/[workspaceId]/files/components/file-viewer/rich-markdown-editor/mention/mention-node.ts

@@ -1,5 +1,5 @@
 import type { JSONContent, MarkdownToken } from '@tiptap/core'
-import { Node } from '@tiptap/core'
+import { InputRule, Node } from '@tiptap/core'
 import { toSimHref } from './sim-link'
 import type { MentionKind } from './types'
 
@@ -103,4 +103,30 @@ export const MarkdownMention = Node.create({
     const { kind, id, label } = node.attrs as MentionAttrs
     return `[${escapeLabel(label)}](${toSimHref(kind, id)})`
   },
+
+  /**
+   * Typing the portable `[label](sim:<kind>/<id>)` syntax inline turns it into a chip on the closing
+   * paren — so live typing matches the paste/load path (which converts it via the tokenizer above). The
+   * rule lives on this node, which sits before {@link MarkdownLinkInputRule} in the extension list, so it
+   * claims the `sim:` form first; every other `[text](url)` falls through to the link rule untouched.
+   */
+  addInputRules() {
+    const type = this.type
+    return [
+      new InputRule({
+        find: /\[((?:\\.|[^\]\\])+)\]\(sim:([a-z_]+)\/([^)\s]+)\)$/,
+        handler: ({ state, range, match }) => {
+          const [, rawLabel, kind, id] = match
+          if (!kind || !id) return null
+          // Replace the whole `[label](sim:…)` match with the chip (nodeInputRule would keep the
+          // surrounding brackets, as it only swaps the first capture group).
+          state.tr.replaceWith(
+            range.from,
+            range.to,
+            type.create({ kind, id, label: unescapeLabel(rawLabel ?? '') })
+          )
+        },
+      }),
+    ]
+  },
 })