fix(mcp): restore comma-separated array input; stop spurious draft reset on tool load

Two more follow-up gaps:

- Holding every JSON.parse failure in a local draft blocked the
  documented comma-separated array shorthand (see the placeholder text)
  from ever reaching toolArgs, since plain comma-separated text is
  never valid JSON. Only an in-progress JSON array/object literal
  (starting with `[` or `{`) needs to stay in the draft until valid;
  plain array-typed text that isn't attempting JSON persists
  immediately as before, letting the execute route's existing
  comma-split/wrap coercion handle it as designed.

- draftResetKey always included the live selectedToolConfig schema
  signature, even when cachedSchema wins the `toolSchema` resolution.
  That segment flips from empty to populated the moment mcpTools
  finishes an unrelated async load, wiping in-progress drafts though
  neither the rendered schema nor the stored args changed. The live
  signature now only factors into the key when there's no cached
  snapshot for toolSchema to prefer.

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/[workflowId]/components/panel/components/editor/components/sub-block/components/mcp-dynamic-args/mcp-dynamic-args.tsx

@@ -52,6 +52,17 @@ function schemaSignature(schema: unknown): string {
   return schema ? JSON.stringify(schema) : ''
 }
 
+/**
+ * True when text looks like an attempted JSON array/object literal (starts with `[`
+ * or `{`), as opposed to plain freeform text. Used to tell an in-progress, incomplete
+ * JSON literal (which must not persist until valid — see `requiresJsonValue`) apart
+ * from the comma-separated/plain-text shorthand array params also accept.
+ */
+function looksLikeJsonLiteral(text: string): boolean {
+  const trimmed = text.trim()
+  return trimmed.startsWith('[') || trimmed.startsWith('{')
+}
+
 interface McpDynamicArgsProps {
   blockId: string
   subBlockId: string
@@ -115,15 +126,16 @@ export function McpDynamicArgs({
    * reach tool execution. A draft is only displayed while its baseline still matches
    * the live persisted value, so an external change to that value (undo/redo, a diff
    * baseline switch, a collaborator's edit) can't be shadowed by stale draft text.
-   * Drafts also reset wholesale whenever the selected tool or either schema source
-   * changes — `toolSchema` prefers the cached `_toolSchema` snapshot over the live
-   * discovered schema, so the reset key tracks both independently rather than the
-   * resolved `toolSchema`, which wouldn't change on a live-only refresh.
+   * Drafts also reset wholesale whenever the selected tool or the schema actually
+   * backing `toolSchema` changes. The live discovered schema only factors in when
+   * there's no cached snapshot to prefer — otherwise it's not what's rendered, so
+   * live schema arriving/changing while a cached snapshot is already in effect
+   * (e.g. `mcpTools` finishing an async load) must not spuriously reset drafts.
    */
   const [invalidJsonDrafts, setInvalidJsonDrafts] = useState<
     Record<string, { text: string; baseline: string }>
   >({})
-  const draftResetKey = `${selectedTool ?? ''}|${schemaSignature(cachedSchema)}|${schemaSignature(selectedToolConfig?.inputSchema)}`
+  const draftResetKey = `${selectedTool ?? ''}|${schemaSignature(cachedSchema)}|${cachedSchema ? '' : schemaSignature(selectedToolConfig?.inputSchema)}`
   const [prevDraftResetKey, setPrevDraftResetKey] = useState(draftResetKey)
   if (prevDraftResetKey !== draftResetKey) {
     setPrevDraftResetKey(draftResetKey)
@@ -343,6 +355,11 @@ export function McpDynamicArgs({
                 updateParameter(paramName, JSON.parse(newValue))
                 clearDraft()
               } catch {
+                if (paramSchema.type === 'array' && !looksLikeJsonLiteral(newValue)) {
+                  updateParameter(paramName, newValue)
+                  clearDraft()
+                  return
+                }
                 setInvalidJsonDrafts((prev) => ({
                   ...prev,
                   [paramName]: { text: newValue, baseline: valueSignature },